import json
import pickle
import random
import nltk
import numpy as np
import tflearn
import gradio as gr
import requests
import time
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
import torch
import pandas as pd
import os
import chromedriver_autoinstaller
from nltk.tokenize import word_tokenize
from nltk.stem.lancaster import LancasterStemmer

# Ensure necessary NLTK resources are downloaded
nltk.download('punkt')

# Initialize the stemmer
stemmer = LancasterStemmer()

# Load intents.json
try:
    with open("intents.json") as file:
        data = json.load(file)
except FileNotFoundError:
    raise FileNotFoundError("Error: 'intents.json' file not found. Ensure it exists in the current directory.")

# Load preprocessed data from pickle
try:
    with open("data.pickle", "rb") as f:
        words, labels, training, output = pickle.load(f)
except FileNotFoundError:
    raise FileNotFoundError("Error: 'data.pickle' file not found. Ensure it exists and matches the model.")

# Build the model structure
net = tflearn.input_data(shape=[None, len(training[0])])
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, 8)
net = tflearn.fully_connected(net, len(output[0]), activation="softmax")
net = tflearn.regression(net)

# Load the trained model
model = tflearn.DNN(net)
try:
    model.load("MentalHealthChatBotmodel.tflearn")
except FileNotFoundError:
    raise FileNotFoundError("Error: Trained model file 'MentalHealthChatBotmodel.tflearn' not found.")

# Function to process user input into a bag-of-words format
def bag_of_words(s, words):
    bag = [0 for _ in range(len(words))]
    s_words = word_tokenize(s)
    s_words = [stemmer.stem(word.lower()) for word in s_words if word.lower() in words]
    for se in s_words:
        for i, w in enumerate(words):
            if w == se:
                bag[i] = 1
    return np.array(bag)

# Chat function
def chat(message, history):
    history = history or []
    message = message.lower()
    
    try:
        # Predict the tag
        results = model.predict([bag_of_words(message, words)])
        results_index = np.argmax(results)
        tag = labels[results_index]

        # Match tag with intent and choose a random response
        for tg in data["intents"]:
            if tg['tag'] == tag:
                responses = tg['responses']
                response = random.choice(responses)
                break
        else:
            response = "I'm sorry, I didn't understand that. Could you please rephrase?"

    except Exception as e:
        response = f"An error occurred: {str(e)}"
    
    history.append((message, response))
    return history, history


# Sentiment analysis setup
tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")

# Emotion detection setup
@st.cache_resource
def load_emotion_model():
    tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
    model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
    return tokenizer, model

tokenizer_emotion, model_emotion = load_emotion_model()

# Google Places API setup for wellness professionals
url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"
api_key = "GOOGLE_API_KEY"

# Install Chrome and Chromedriver for web scraping
def install_chrome_and_driver():
    os.system("apt-get update")
    os.system("apt-get install -y wget curl")
    os.system("wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb")
    os.system("dpkg -i google-chrome-stable_current_amd64.deb")
    os.system("apt-get install -y -f")
    os.system("google-chrome-stable --version")
    chromedriver_autoinstaller.install()

install_chrome_and_driver()

# Function to get places data using Google Places API
def get_places_data(query, location, radius, api_key, next_page_token=None):
    params = {
        "query": query,
        "location": location,
        "radius": radius,
        "key": api_key
    }

    if next_page_token:
        params["pagetoken"] = next_page_token

    response = requests.get(url, params=params)
    if response.status_code == 200:
        return response.json()
    else:
        return None

# Main function to fetch wellness professional data and display on map
def get_wellness_professionals(location):
    query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist OR nutritionist OR wellness doctor OR holistic practitioner OR integrative medicine OR chiropractor OR naturopath"
    radius = 50000  # 50 km radius
    data = get_places_data(query, location, radius, api_key)

    if data:
        results = data.get('results', [])
        wellness_data = []
        for place in results:
            name = place.get("name")
            address = place.get("formatted_address")
            latitude = place.get("geometry", {}).get("location", {}).get("lat")
            longitude = place.get("geometry", {}).get("location", {}).get("lng")
            wellness_data.append([name, address, latitude, longitude])
        return wellness_data
    return []

# Gradio interface setup for user interaction
def user_interface(message, location, history):
    history, history = chat(message, history)
    
    # Sentiment analysis
    inputs = tokenizer_sentiment(message, return_tensors="pt")
    outputs = model_sentiment(**inputs)
    sentiment = ["Negative", "Neutral", "Positive"][torch.argmax(outputs.logits, dim=1).item()]
    
    # Emotion detection
    pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
    emotion_result = pipe(message)
    emotion = emotion_result[0]['label']
    
    # Get wellness professionals
    wellness_data = get_wellness_professionals(location)
    
    return history, history, sentiment, emotion, wellness_data

# Gradio chatbot interface
chatbot = gr.Chatbot(label="Mental Health Chatbot")
location_input = gr.Textbox(label="Enter your location (latitude,longitude)", placeholder="e.g., 21.3,-157.8")

# Gradio interface definition
demo = gr.Interface(
    user_interface,
    [gr.Textbox(label="Message"), location_input, "state"],
    [chatbot, "state", "text", "text", "json"],
    allow_flagging="never",
    title="Mental Health & Well-being Assistant"
)

# Launch Gradio interface
if __name__ == "__main__":
    demo.launch()