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

# 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

# Load tokenizer and model for sentiment analysis
tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")

# Google Places API endpoint
url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"

# Your actual Google API Key (replace with your key)
api_key = "AIzaSyCcfJzMFfuv_1LN7JPTJJYw_aS0A_SLeW0"  # Replace with your own Google API key

# Search query for wellness professionals in Hawaii
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 in Hawaii"

# Approximate latitude and longitude for Hawaii (e.g., Oahu)
location = "21.3,-157.8"  # Center of Hawaii (Oahu)
radius = 50000  # 50 km radius

# Install Chrome and Chromedriver
def install_chrome_and_driver():
    # Install Chrome (if not already installed)
    os.system("apt-get update && apt-get install -y wget curl sudo")
    os.system("wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb")
    os.system("sudo dpkg -i google-chrome-stable_current_amd64.deb")
    os.system("sudo apt-get install -y -f")
    os.system("google-chrome-stable --version")

    # Fix ownership of /etc/sudo.conf
    os.system("sudo chown root:root /etc/sudo.conf")

    # Verify Chrome installation
    os.system("which google-chrome-stable")
    if not os.path.exists("/usr/bin/google-chrome-stable"):
        raise RuntimeError("Google Chrome was not installed correctly")

    # Check if CUDA libraries are available and install them if present
    try:
        os.system("apt-get install -y cuda")
        os.system("apt-get install -y libcudart.so.11.0")
    except subprocess.CalledProcessError:
        print("CUDA libraries not found or installation failed. Proceeding without GPU support.")

    # Install Chromedriver (if not already installed)
    chromedriver_autoinstaller.install()

    # Verify Chromedriver installation
    os.system("which chromedriver")
    if not os.path.exists("/usr/local/bin/chromedriver"):
        raise RuntimeError("ChromeDriver was not installed correctly")

install_chrome_and_driver()

# Function to send a request to Google Places API and fetch places data
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

# Function to fetch detailed information for a specific place using its place_id
def get_place_details(place_id, api_key):
    details_url = places_details_url
    params = {
        "place_id": place_id,
        "key": api_key
    }
    response = requests.get(details_url, params=params)

    if response.status_code == 200:
        details_data = response.json().get("result", {})
        return {
            "opening_hours": details_data.get("opening_hours", {}).get("weekday_text", "Not available"),
            "reviews": details_data.get("reviews", "Not available"),
            "phone_number": details_data.get("formatted_phone_number", "Not available"),
            "website": details_data.get("website", "Not available")
        }
    else:
        return {}

# Scrape website URL from Google Maps results (using Selenium)
def scrape_website_from_google_maps(place_name):
    chrome_options = Options()
    chrome_options.add_argument("--headless")
    chrome_options.add_argument("--no-sandbox")
    chrome_options.add_argument("--disable-dev-shm-usage")

    driver = webdriver.Chrome(options=chrome_options)
    search_url = f"https://www.google.com/maps/search/{place_name.replace(' ', '+')}"
    driver.get(search_url)
    time.sleep(5)

    try:
        website_element = driver.find_element_by_xpath('//a[contains(@aria-label, "Visit") and contains(@aria-label, "website")]')
        website_url = website_element.get_attribute('href')
    except:
        website_url = "Not available"

    driver.quit()
    return website_url

# Scraping the website to extract phone number or email
def scrape_website_for_contact_info(website):
    phone_number = "Not available"
    email = "Not available"

    try:
        response = requests.get(website, timeout=5)
        soup = BeautifulSoup(response.content, 'html.parser')

        phone_match = re.search(r'\(?\+?[0-9]*\)?[0-9_\- \(\)]*', soup.get_text())
        if phone_match:
            phone_number = phone_match.group()

        email_match = re.search(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', soup.get_text())
        if email_match:
            email = email_match.group()

    except Exception as e:
        print(f"Error scraping website {website}: {e}")

    return phone_number, email

# Function to fetch all places data including pagination
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', [])
            if not results:
                break

            for place in results:
                place_id = place.get("place_id")
                name = place.get("name")
                address = place.get("formatted_address")
                rating = place.get("rating", "Not available")
                business_status = place.get("business_status", "Not available")
                user_ratings_total = place.get("user_ratings_total", "Not available")
                website = place.get("website", "Not available")
                types = ", ".join(place.get("types", []))
                location = place.get("geometry", {}).get("location", {})
                latitude = location.get("lat", "Not available")
                longitude = location.get("lng", "Not available")

                details = get_place_details(place_id, api_key)
                phone_number = details.get("phone_number", "Not available")
                if phone_number == "Not available" and website != "Not available":
                    phone_number, email = scrape_website_for_contact_info(website)
                else:
                    email = "Not available"

                if website == "Not available":
                    website = scrape_website_from_google_maps(name)

                all_results.append([name, address, phone_number, rating, business_status,
                                    user_ratings_total, website, types, latitude, longitude,
                                    details.get("opening_hours", "Not available"),
                                    details.get("reviews", "Not available"), email])

            next_page_token = data.get('next_page_token')
            if not next_page_token:
                break

            time.sleep(2)
        else:
            break

    return all_results

# Function to save results to CSV file
def save_to_csv(data, filename):
    with open(filename, mode='w', newline='', encoding='utf-8') as file:
        writer = csv.writer(file)
        writer.writerow([
            "Name", "Address", "Phone", "Rating", "Business Status",
            "User Ratings Total", "Website", "Types", "Latitude", "Longitude",
            "Opening Hours", "Reviews", "Email"
        ])
        writer.writerows(data)
    print(f"Data saved to {filename}")

# Main function to execute script
def main():
    google_places_data = get_all_places(query, location, radius, api_key)
    if google_places_data:
        save_to_csv(google_places_data, "wellness_professionals_hawaii.csv")
    else:
        print("No data found.")

# Gradio UI setup
with gr.Blocks() as demo:
    # Display header
    gr.Markdown("# Emotion Detection and Well-Being Suggestions")

    # User input for text (emotion detection)
    user_input_emotion = gr.Textbox(lines=1, label="How are you feeling today?")

    # Model prediction for emotion detection
    def predict_emotion(text):
        pipe = pipeline("text-classification", model=model, tokenizer=tokenizer)
        result = pipe(text)
        emotion = result[0]['label']
        return emotion

    user_input_emotion.change(predict_emotion, inputs=user_input_emotion, outputs=gr.Textbox(label="Emotion Detected"))

    # Provide suggestions based on the detected emotion
    def show_suggestions(emotion):
        if emotion == 'joy':
            return "You're feeling happy! Keep up the great mood!\nUseful Resources:\n[Relaxation Techniques](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)\n[Dealing with Stress](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/m1vaUGtyo-A)"
        elif emotion == 'anger':
            return "You're feeling angry. It's okay to feel this way. Let's try to calm down.\nUseful Resources:\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n[Stress Management Tips](https://www.health.harvard.edu/health-a-to-z)\n[Dealing with Anger](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/MIc299Flibs)"
        elif emotion == 'fear':
            return "You're feeling fearful. Take a moment to breathe and relax.\nUseful Resources:\n[Mindfulness Practices](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)\n[Coping with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/yGKKz185M5o)"
        elif emotion == 'sadness':
            return "You're feeling sad. It's okay to take a break.\nUseful Resources:\n[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)\n[Dealing with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/-e-4Kx5px_I)"
        elif emotion == 'surprise':
            return "You're feeling surprised. It's okay to feel neutral!\nUseful Resources:\n[Managing Stress](https://www.health.harvard.edu/health-a-to-z)\n[Coping Strategies](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)\n\nRelaxation Videos:\n[Watch on YouTube](https://youtu.be/m1vaUGtyo-A)"

    emotion_output = gr.Textbox(label="Emotion Detected")
    emotion_output.change(show_suggestions, inputs=emotion_output, outputs=gr.Textbox(label="Suggestions"))

    # Button for summary
    def show_summary(emotion):
        return f"Emotion Detected: {emotion}\nUseful Resources based on your mood:\n{show_suggestions(emotion)}"

    summary_button = gr.Button("Show Summary")
    summary_output = gr.Textbox(label="Summary")
    summary_button.click(show_summary, inputs=emotion_output, outputs=summary_output)

    # Chatbot functionality
    chatbot = gr.Chatbot(label="Chat")
    message_input = gr.Textbox(lines=1, label="Message")
    history_state = gr.State([])

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

    message_input.submit(chat, inputs=[message_input, history_state], outputs=[chatbot, history_state])

    # User input for text (sentiment analysis)
    user_input_sentiment = gr.Textbox(lines=1, label="Enter text to analyze sentiment:")

    # Prediction button for sentiment analysis
    def predict_sentiment(text):
        inputs = tokenizer_sentiment(text, return_tensors="pt")
        with torch.no_grad():
            outputs = model_sentiment(**inputs)
        predicted_class = torch.argmax(outputs.logits, dim=1).item()
        sentiment = ["Negative", "Neutral", "Positive"][predicted_class]
        return sentiment

    sentiment_output = gr.Textbox(label="Predicted Sentiment")
    user_input_sentiment.change(predict_sentiment, inputs=user_input_sentiment, outputs=sentiment_output)

    # Button to fetch wellness professionals data
    fetch_button = gr.Button("Fetch Wellness Professionals Data")
    data_output = gr.Dataframe(headers=["Name", "Address", "Phone", "Rating", "Business Status", "User Ratings Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])

    def fetch_data():
        all_results = get_all_places(query, location, radius, api_key)
        if all_results:
            return pd.DataFrame(all_results, columns=["Name", "Address", "Phone", "Rating", "Business Status", "User Ratings Total", "Website", "Types", "Latitude", "Longitude", "Opening Hours", "Reviews", "Email"])
        else:
            return "No data found."

    fetch_button.click(fetch_data, inputs=None, outputs=data_output)

# Launch Gradio interface
demo.launch()