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

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

# Constants
GOOGLE_MAPS_API_KEY = os.environ.get("GOOGLE_API_KEY")  # Get API key from environment variable
if not GOOGLE_MAPS_API_KEY:
    raise ValueError("Error: GOOGLE_MAPS_API_KEY environment variable not set.")

url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"
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"

# Chatbot
stemmer = LancasterStemmer()

try:
    with open("intents.json") as file:
        data = json.load(file)
except FileNotFoundError:
    raise FileNotFoundError("Error: 'intents.json' file not found.")

try:
    with open("data.pickle", "rb") as file:
        words, labels, training, output = pickle.load(file)
except FileNotFoundError:
    raise FileNotFoundError("Error: 'data.pickle' file not found.")

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")

model = tflearn.DNN(net)

try:
    model.load("MentalHealthChatBotmodel.tflearn")
except FileNotFoundError:
    raise FileNotFoundError("Error: Trained model file 'MentalHealthChatBotmodel.tflearn' not found.")

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)

def chat(message, history):
    history = history or []
    message = message.lower()
    try:
        results = model.predict([bag_of_words(message, words)])
        results_index = np.argmax(results)
        tag = labels[results_index]
        for tg in data["intents"]:
            if tg['tag'] == tag:
                responses = tg['responses']
                response = random.choice(responses)
        history.append((message, response))
    except Exception as e:
        response = "I'm sorry, I didn't understand that. Could you please rephrase?"
        history.append((message, response))
    return history, history

# Sentiment Analysis
tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")

def analyze_sentiment(text):
    try:
        inputs = tokenizer(text, return_tensors="pt")
        with torch.no_grad():
            logits = model_sentiment(**inputs).logits
        sentiment = ["Negative", "Neutral", "Positive"][torch.argmax(logits)]
        return f"**Predicted Sentiment:** {sentiment}"
    except Exception as e:
        return f"Error analyzing sentiment: {str(e)}"

# Emotion Detection
def detect_emotion(text):
    # Implement your own emotion detection logic
    return "Emotion detection not implemented"

# Suggestion Generation
def provide_suggestions(emotion):
    # Implement your own suggestion generation logic
    return pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])

# Google Places API Functions
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:
        print(f"Error: {response.status_code} - {response.text}")
        return None

def get_place_details(place_id, api_key):
    params = {"place_id": place_id, "key": api_key}
    response = requests.get(places_details_url, params=params)
    if response.status_code == 200:
        details_data = response.json().get("result", {})
        return {
            "phone_number": details_data.get("formatted_phone_number", "Not available"),
            "website": details_data.get("website", "Not available")
        }
    else:
        return {}

def get_all_places(query, location, radius, api_key):
    all_results = []
    next_page_token = None
    while True:
        data = get_places_data(query, location, radius, api_key, next_page_token)
        if data:
            results = data.get('results', [])
            for place in results:
                place_id = place.get("place_id")
                name = place.get("name")
                address = place.get("formatted_address")
                details = get_place_details(place_id, api_key)
                phone_number = details.get("phone_number", "Not available")
                website = details.get("website", "Not available")
                all_results.append([name, address, phone_number, website])
            next_page_token = data.get('next_page_token')
            if not next_page_token:
                break
        else:
            break
    return all_results

# Gradio Interface
def gradio_interface(message, location, state):
    history = state or []
    if message:
        history, _ = chat(message, history)
        sentiment = analyze_sentiment(message)
        emotion = detect_emotion(message)
        suggestions = provide_suggestions(emotion)
        if location:
            try:
                wellness_results = pd.DataFrame(get_all_places(query, location, 50000, GOOGLE_MAPS_API_KEY), columns=["Name", "Address", "Phone", "Website"])
            except Exception as e:
                wellness_results = pd.DataFrame([["Error fetching data: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
        else:
            wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
    else:
        sentiment = ""
        emotion = ""
        suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
        wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])

    return history, sentiment, emotion, suggestions, wellness_results, history

gr.Interface(
    fn=gradio_interface,
    inputs=[
        gr.Textbox(label="Enter your message", placeholder="How are you feeling today?"),
        gr.Textbox(label="Enter your location (e.g., 'Hawaii, USA')", placeholder="Enter your location (optional)"),
        gr.State(),
        gr.Button("Send")
    ],
    outputs=[
        gr.Chatbot(label="Chatbot Responses"),
        gr.Textbox(label="Sentiment Analysis"),
        gr.Textbox(label="Emotion Detected"),
        gr.DataFrame(label="Suggested Articles & Videos"),
        gr.DataFrame(label="Nearby Wellness Professionals"),
        gr.State()
    ],
    live=True,
    title="Mental Health Chatbot with Wellness Professional Search",
    description="This chatbot provides mental health support with sentiment analysis, emotion detection, suggestions, and a list of nearby wellness professionals. Interact with the chatbot first, then enter a location to search."
).launch(debug=True, share=True)