import os
import gc
import csv
import socket
import json
import huggingface_hub
import requests

import re as r
import gradio as gr
import pandas as pd

from huggingface_hub import Repository
from urllib.request import urlopen
from transformers import AutoTokenizer, AutoModelWithLMHead 

## connection with HF datasets
HF_TOKEN = os.environ.get("HF_TOKEN")
# DATASET_NAME = "emotion_detection_dataset"
# DATASET_REPO_URL = f"https://huggingface.co/datasets/pragnakalp/{DATASET_NAME}"
DATASET_REPO_URL = "https://huggingface.co/datasets/pragnakalp/emotion_detection_dataset"
DATA_FILENAME = "emotion_detection_logs.csv"
DATA_FILE = os.path.join("emotion_detection_logs", DATA_FILENAME)
DATASET_REPO_ID = "pragnakalp/emotion_detection_dataset"
print("is none?", HF_TOKEN is None)
try:
    hf_hub_download(
        repo_id=DATASET_REPO_ID,
        filename=DATA_FILENAME,
        cache_dir=DATA_DIRNAME,
        force_filename=DATA_FILENAME
    )
    
except:
    print("file not found")

repo = Repository(
    local_dir="emotion_detection_logs", clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
)

SENTENCES_VALUE = """Raj loves Simran.\nLast year I lost my Dog.\nI bought a new phone!\nShe is scared of cockroaches.\nWow! I was not expecting that.\nShe got mad at him."""
## load model
cwd = os.getcwd()
model_path = os.path.join(cwd)
tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-emotion")
model_base = AutoModelWithLMHead.from_pretrained(model_path)

def getIP():
    ip_address = ''
    try:
    	d = str(urlopen('http://checkip.dyndns.com/')
    			.read())
    
    	return r.compile(r'Address: (\d+\.\d+\.\d+\.\d+)').search(d).group(1)
    except Exception as e:
        print("Error while getting IP address -->",e)
        return ip_address

def get_location(ip_addr):
    location = {}
    try:
        ip=ip_addr
    
        req_data={
            "ip":ip,
            "token":"pkml123"
        }
        url = "https://demos.pragnakalp.com/get-ip-location"
    
        # req_data=json.dumps(req_data)
        # print("req_data",req_data)
        headers = {'Content-Type': 'application/json'}
    
        response = requests.request("POST", url, headers=headers, data=json.dumps(req_data))
        response = response.json()
        print("response======>>",response)
        return response
    except Exception as e:
        print("Error while getting location -->",e)
        return location


"""
generate emotions of the sentences
"""
def get_emotion(text):

    # input_ids = tokenizer.encode(text + '</s>', return_tensors='pt')
    input_ids = tokenizer.encode(text, return_tensors='pt')
    output = model_base.generate(input_ids=input_ids,
                                 max_length=2)

    dec = [tokenizer.decode(ids) for ids in output]
    label = dec[0]
    gc.collect()
    return label

def generate_emotion(article):
    table = {'Input':[], 'Detected Emotion':[]}
    if article.strip():
        sen_list = article
        sen_list = sen_list.split('\n')
        while("" in sen_list):
            sen_list.remove("")
        sen_list_temp = sen_list[0:]
        print(sen_list_temp)
        results_dict = []
        results = []
    
        for sen in sen_list_temp:
            if(sen.strip()):
                cur_result = get_emotion(sen)
    
                results.append(cur_result)
                results_dict.append(
                    {
                        'sentence': sen,
                        'emotion': cur_result
                    }
                )
                
        table = {'Input':sen_list_temp, 'Detected Emotion':results}
        gc.collect()
        save_data_and_sendmail(article,results_dict,sen_list, results)
        return pd.DataFrame(table)
    else:
        raise gr.Error("Please enter text in inputbox!!!!")
    
"""
Save generated details
"""
def save_data_and_sendmail(article,results_dict,sen_list,results):
    try:
     
        ip_address= getIP()
        print(ip_address)
        location = get_location(ip_address)
        print(location)
        
        add_csv = [article,results_dict,ip_address,location]
        with open(DATA_FILE, "a") as f:
            writer = csv.writer(f)
            # write the data
            writer.writerow(add_csv)
            commit_url = repo.push_to_hub()
            print("commit data   :",commit_url)
    
        url = 'https://pragnakalpdev33.pythonanywhere.com/HF_space_emotion_detection_demo'
        # url = 'https://pragnakalpdev35.pythonanywhere.com/HF_space_emotion_detection'
        
        myobj = {"sentences":sen_list,"gen_results":results,"ip_addr":ip_address,'loc':location}
        response = requests.post(url, json = myobj)
        print("response=-----=",response.status_code)
   
    except Exception as e:
        return "Error while sending mail" + str(e)
        
    return "Successfully save data"
    
"""
UI design for demo using gradio app
"""
inputs = gr.Textbox(value=SENTENCES_VALUE,lines=3, label="Sentences",elem_id="inp_div")
outputs = [gr.Dataframe(row_count = (3, "dynamic"), col_count=(2, "fixed"), label="Here is the Result", headers=["Input","Detected Emotion"],wrap=True)]

demo = gr.Interface(
    generate_emotion,
    inputs,
    outputs,
    title="Emotion Detection",
    css=".gradio-container {background-color: lightgray} #inp_div {background-color: #FB3D5;}",
    article="""<p style='text-align: center;'>Provide us your <a href="https://www.pragnakalp.com/contact/" target="_blank">feedback</a> on this demo and feel free 
            to contact us at <a href="mailto:letstalk@pragnakalp.com" target="_blank">letstalk@pragnakalp.com</a> if you want to have your own Emotion Detection system. 
            We will be happy to serve you for your requirement. And don't forget to check out more interesting 
            <a href="https://www.pragnakalp.com/services/natural-language-processing-services/" target="_blank">NLP services</a> we are offering.</p>
            <p style='text-align: center;'>Developed by: <a href="https://www.pragnakalp.com" target="_blank">Pragnakalp Techlabs</a></p>"""
)
demo.launch()