# from fastapi import FastAPI, Request
# import uvicorn

# # Initialize FastAPI app
# app = FastAPI()

# # FastAPI route to handle WhatsApp webhook
# @app.post("/whatsapp-webhook")
# async def whatsapp_webhook(request: Request):
#     data = await request.json()  # Parse incoming JSON data
#     print(f"Received data: {data}")  # Log incoming data for debugging
#     return {"status": "success", "received_data": data}

# # Run the FastAPI app with Uvicorn
# if __name__ == "__main__":
#     uvicorn.run(app, host="0.0.0.0", port=7860)

#!/usr/bin/env python
# coding: utf-8


# In[2]:


#pip install  evernote-sdk-python3
# import evernote.edam.notestore.NoteStore as NoteStore
# import evernote.edam.type.ttypes as Types
# from evernote.api.client import EvernoteClient


# In[3]:


import os
import yaml
import pandas as pd
import numpy as np

from datetime import datetime, timedelta

# perspective generation
import openai
import os
from openai import OpenAI

import gradio as gr

import json

import sqlite3
import uuid
import socket
import difflib
import time
import shutil
import requests
import re

import json
import markdown
from fpdf import FPDF
import hashlib

from transformers import pipeline
from transformers.pipelines.audio_utils import ffmpeg_read

from todoist_api_python.api import TodoistAPI

# from flask import Flask, request, jsonify
from twilio.rest import Client

import asyncio
import uvicorn
import fastapi
from fastapi import FastAPI, Request, HTTPException
from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse
from fastapi.staticfiles import StaticFiles
from pathlib import Path

import nest_asyncio
from twilio.twiml.messaging_response import MessagingResponse

from requests.auth import HTTPBasicAuth

from google.cloud import storage, exceptions  # Import exceptions for error handling
from google.cloud.exceptions import NotFound
from google.oauth2 import service_account

from reportlab.pdfgen import canvas
from reportlab.lib.pagesizes import letter
from reportlab.pdfbase import pdfmetrics
from reportlab.lib import colors
from reportlab.pdfbase.ttfonts import TTFont

import logging

# Configure logging
logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)


# In[4]:

# Access the API keys and other configuration data
openai_api_key = os.environ["OPENAI_API_KEY"]
# Access the API keys and other configuration data
todoist_api_key = os.environ["TODOIST_API_KEY"]

EVERNOTE_API_TOKEN = os.environ["EVERNOTE_API_TOKEN"]

account_sid = os.environ["TWILLO_ACCOUNT_SID"]
auth_token = os.environ["TWILLO_AUTH_TOKEN"]
twilio_phone_number = os.environ["TWILLO_PHONE_NUMBER"]

google_credentials_json = os.environ["GOOGLE_APPLICATION_CREDENTIALS"]
twillo_client = Client(account_sid, auth_token)

# Set the GOOGLE_APPLICATION_CREDENTIALS environment variable

# Load Reasoning Graph JSON File
def load_reasoning_json(filepath):
    """Load JSON file and return the dictionary."""
    with open(filepath, "r") as file:
        data = json.load(file)
    return data

# Load Action Map
def load_action_map(filepath):
    """Load action map JSON file and map strings to actual function objects."""
    with open(filepath, "r") as file:
        action_map_raw = json.load(file)
    # Map string names to actual functions using globals()
    return {action: globals()[func_name] for action, func_name in action_map_raw.items()}


# In[5]:


# Define all actions as functions

def find_reference(task_topic):
    """Finds a reference related to the task topic."""
    print(f"Finding reference for topic: {task_topic}")
    return f"Reference found for topic: {task_topic}"

def generate_summary(reference):
    """Generates a summary of the reference."""
    print(f"Generating summary for reference: {reference}")
    return f"Summary of {reference}"

def suggest_relevance(summary):
    """Suggests how the summary relates to the project."""
    print(f"Suggesting relevance of summary: {summary}")
    return f"Relevance of {summary} suggested"

def tool_research(task_topic):
    """Performs tool research and returns analysis."""
    print("Performing tool research")
    return "Tool analysis data"

def generate_comparison_table(tool_analysis):
    """Generates a comparison table for a competitive tool."""
    print(f"Generating comparison table for analysis: {tool_analysis}")
    return f"Comparison table for {tool_analysis}"

def generate_integration_memo(tool_analysis):
    """Generates an integration memo for a tool."""
    print(f"Generating integration memo for analysis: {tool_analysis}")
    return f"Integration memo for {tool_analysis}"

def analyze_issue(task_topic):
    """Analyzes an issue and returns the analysis."""
    print("Analyzing issue")
    return "Issue analysis data"

def generate_issue_memo(issue_analysis):
    """Generates an issue memo based on the analysis."""
    print(f"Generating issue memo for analysis: {issue_analysis}")
    return f"Issue memo for {issue_analysis}"

def list_ideas(task_topic):
    """Lists potential ideas for brainstorming."""
    print("Listing ideas")
    return ["Idea 1", "Idea 2", "Idea 3"]

def construct_matrix(ideas):
    """Constructs a matrix (e.g., feasibility or impact/effort) for the ideas."""
    print(f"Constructing matrix for ideas: {ideas}")
    return {"Idea 1": "High Impact/Low Effort", "Idea 2": "Low Impact/High Effort", "Idea 3": "High Impact/High Effort"}

def prioritize_ideas(matrix):
    """Prioritizes ideas based on the matrix."""
    print(f"Prioritizing ideas based on matrix: {matrix}")
    return ["Idea 3", "Idea 1", "Idea 2"]

def setup_action_plan(prioritized_ideas):
    """Sets up an action plan based on the prioritized ideas."""
    print(f"Setting up action plan for ideas: {prioritized_ideas}")
    return f"Action plan created for {prioritized_ideas}"

def unsupported_task(task_topic):
    """Handles unsupported tasks."""
    print("Task not supported")
    return "Unsupported task"


# In[6]:


todoist_api = TodoistAPI(todoist_api_key)

# Fetch recent Todoist task
def fetch_todoist_task():
    try:
        tasks = todoist_api.get_tasks()
        if tasks:
            recent_task = tasks[0]  # Fetch the most recent task
            return f"Recent Task: {recent_task.content}"
        return "No tasks found in Todoist."
    except Exception as e:
        return f"Error fetching tasks: {str(e)}"

def add_to_todoist(task_topic, todoist_priority = 3):
    try:
        # Create a task in Todoist using the Todoist API
        # Assuming you have a function `todoist_api.add_task()` that handles the API request
        todoist_api.add_task(
            content=task_topic,
            priority=todoist_priority
        )
        msg = f"Task added: {task_topic} with priority {todoist_priority}"
        logger.debug(msg)

        return msg
    except Exception as e:
        # Return an error message if something goes wrong
        return f"An error occurred: {e}"    

# def save_todo(reasoning_steps):
#     """
#     Save reasoning steps to Todoist as tasks.

#     Args:
#         reasoning_steps (list of dict): A list of steps with "step" and "priority" keys.
#     """
#     try:
#         # Validate that reasoning_steps is a list
#         if not isinstance(reasoning_steps, list):
#             raise ValueError("The input reasoning_steps must be a list.")

#         # Iterate over the reasoning steps
#         for step in reasoning_steps:
#             # Ensure each step is a dictionary and contains required keys
#             if not isinstance(step, dict) or "step" not in step or "priority" not in step:
#                 logger.error(f"Invalid step data: {step}, skipping.")
#                 continue

#             task_content = step["step"]
#             priority_level = step["priority"]

#             # Map priority to Todoist's priority levels (1 - low, 4 - high)
#             priority_mapping = {"Low": 1, "Medium": 2, "High": 4}
#             todoist_priority = priority_mapping.get(priority_level, 1)  # Default to low if not found

#             # Create a task in Todoist using the Todoist API
#             # Assuming you have a function `todoist_api.add_task()` that handles the API request
#             todoist_api.add_task(
#                 content=task_content,
#                 priority=todoist_priority
#             )

#             logger.debug(f"Task added: {task_content} with priority {priority_level}")

#         return "All tasks processed."
#     except Exception as e:
#         # Return an error message if something goes wrong
#         return f"An error occurred: {e}"


# In[7]:


# evernote_client = EvernoteClient(token=EVERNOTE_API_TOKEN, sandbox=False)
# note_store = evernote_client.get_note_store()

# def add_to_evernote(task_topic, notebook_title="Inspirations"):
#     """
#     Add a task topic to the 'Inspirations' notebook in Evernote. If the notebook doesn't exist, create it.

#     Args:
#         task_topic (str): The content of the task to be added.
#         notebook_title (str): The title of the Evernote notebook. Default is 'Inspirations'.
#     """
#     try:
#         # Check if the notebook exists
#         notebooks = note_store.listNotebooks()
#         notebook = next((nb for nb in notebooks if nb.name == notebook_title), None)

#         # If the notebook doesn't exist, create it
#         if not notebook:
#             notebook = Types.Notebook()
#             notebook.name = notebook_title
#             notebook = note_store.createNotebook(notebook)

#         # Search for an existing note with the same title
#         filter = NoteStore.NoteFilter()
#         filter.notebookGuid = notebook.guid
#         filter.words = notebook_title
#         notes_metadata_result = note_store.findNotesMetadata(filter, 0, 1, NoteStore.NotesMetadataResultSpec(includeTitle=True))

#         # If a note with the title exists, append to it; otherwise, create a new note
#         if notes_metadata_result.notes:
#             note_guid = notes_metadata_result.notes[0].guid
#             existing_note = note_store.getNote(note_guid, True, False, False, False)
#             existing_note.content = existing_note.content.replace("</en-note>", f"<div>{task_topic}</div></en-note>")
#             note_store.updateNote(existing_note)
#         else:
#             # Create a new note
#             note = Types.Note()
#             note.title = notebook_title
#             note.notebookGuid = notebook.guid
#             note.content = f'<?xml version="1.0" encoding="UTF-8"?>' \
#                            f'<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">' \
#                            f'<en-note><div>{task_topic}</div></en-note>'
#             note_store.createNote(note)

#         print(f"Task '{task_topic}' successfully added to Evernote under '{notebook_title}'.")
#     except Exception as e:
#         print(f"Error adding task to Evernote: {e}")

# Mock Functions for Task Actions
def add_to_evernote(task_topic):
    return f"Task added to Evernote with title '{task_topic}'."


# In[8]:


# Access the API keys and other configuration data
TASK_WORKFLOW_TREE = load_reasoning_json('curify_ideas_reasoning.json')
action_map = load_action_map('action_map.json')

# In[9]:


def generate_task_hash(task_description):
    try:
        # Ensure task_description is a string
        if not isinstance(task_description, str):
            logger.warning("task_description is not a string, attempting conversion.")
            task_description = str(task_description)
        
        # Safely encode with UTF-8 and ignore errors
        encoded_description = task_description.encode("utf-8", errors="ignore")
        task_hash = hashlib.md5(encoded_description).hexdigest()

        logger.debug(f"Generated task hash: {task_hash}")
        return task_hash
    except Exception as e:
        # Log any unexpected issues
        logger.error(f"Error generating task hash: {e}", exc_info=True)
        return 'output'
    
def save_to_google_storage(bucket_name, file_path, destination_blob_name, expiration_minutes = 1440):
    credentials_dict = json.loads(google_credentials_json)

    # Step 3: Use `service_account.Credentials.from_service_account_info` to authenticate directly with the JSON
    credentials = service_account.Credentials.from_service_account_info(credentials_dict)
    gcs_client = storage.Client(credentials=credentials, project=credentials.project_id)

    # Check if the bucket exists; if not, create it
    try:
        bucket = gcs_client.get_bucket(bucket_name)
    except NotFound:
        print(f"❌ Bucket '{bucket_name}' not found. Please check the bucket name.")
        bucket = gcs_client.create_bucket(bucket_name)
        print(f"✅ Bucket '{bucket_name}' created.")
    except Exception as e:
        print(f"❌ An unexpected error occurred: {e}")
        raise
    # Get a reference to the blob
    blob = bucket.blob(destination_blob_name)
    
    # Upload the file
    blob.upload_from_filename(file_path)
    
    # Generate a signed URL for the file
    signed_url = blob.generate_signed_url(
        version="v4",
        expiration=timedelta(minutes=expiration_minutes),
        method="GET"
    )
    print(f"✅ File uploaded to Google Cloud Storage. Signed URL: {signed_url}")
    return signed_url


# Function to check if content is Simplified Chinese
def is_simplified(text):
    simplified_range = re.compile('[\u4e00-\u9fff]')  # Han characters in general
    simplified_characters = [char for char in text if simplified_range.match(char)]
    return len(simplified_characters) > len(text) * 0.5  # Threshold of 50% to be considered simplified

# Function to choose the appropriate font for the content
def choose_font_for_content(content):
    return 'NotoSansSC' if is_simplified(content) else 'NotoSansTC'

# Function to generate and save a document using ReportLab
def generate_document(task_description, md_content, user_name='jayw', bucket_name='curify'):
    logger.debug("Starting to generate document")

    # Hash the task description to generate a unique filename
    task_hash = generate_task_hash(task_description)

    # Truncate the hash if needed (64 characters is sufficient for uniqueness)
    max_hash_length = 64  # Adjust if needed
    truncated_hash = task_hash[:max_hash_length]

    # Generate PDF file locally
    local_filename = f"{truncated_hash}.pdf"  # Use the truncated hash as the local file name
    c = canvas.Canvas(local_filename, pagesize=letter)

    # Paths to the TTF fonts for Simplified and Traditional Chinese
    sc_font_path = 'NotoSansSC-Regular.ttf'  # Path to Simplified Chinese font
    tc_font_path = 'NotoSansTC-Regular.ttf'  # Path to Traditional Chinese font

    try:
        # Register the Simplified Chinese font
        sc_font = TTFont('NotoSansSC', sc_font_path)
        pdfmetrics.registerFont(sc_font)

        # Register the Traditional Chinese font
        tc_font = TTFont('NotoSansTC', tc_font_path)
        pdfmetrics.registerFont(tc_font)
        
        # Set default font (Simplified Chinese or Traditional Chinese depending on content)
        c.setFont('NotoSansSC', 12)
    except Exception as e:
        logger.error(f"Error loading font files: {e}")
        raise RuntimeError("Failed to load one or more fonts. Ensure the font files are accessible.")

    # Set initial Y position for drawing text
    y_position = 750  # Starting position for text

    # Process dictionary and render content
    for key, value in md_content.items():
        # Choose the font based on the key (header)
        c.setFont(choose_font_for_content(key), 14)
        c.drawString(100, y_position, f"# {key}")
        y_position -= 20

        # Choose the font for the value
        c.setFont(choose_font_for_content(str(value)), 12)

        # Add value
        if isinstance(value, list):  # Handle lists
            for item in value:
                c.drawString(100, y_position, f"- {item}")
                y_position -= 15
        else:  # Handle single strings
            c.drawString(100, y_position, value)
            y_position -= 15

        # Check if the page needs to be broken (if Y position is too low)
        if y_position < 100:
            c.showPage()  # Create a new page
            c.setFont('NotoSansSC', 12)  # Reset font
            y_position = 750  # Reset the Y position for the new page

    # Save the PDF
    c.save()

    # Organize files into user-specific folders
    destination_blob_name = f"{user_name}/{truncated_hash}.pdf"

    # Upload to Google Cloud Storage and get the public URL
    public_url = save_to_google_storage(bucket_name, local_filename, destination_blob_name)
    logger.debug("Finished generating document")
    return public_url
    
# In[10]:


def execute_with_retry(sql, params=(), attempts=5, delay=1, db_name = 'curify_ideas.db'):
    for attempt in range(attempts):
        try:
            with sqlite3.connect(db_name) as conn:
                cursor = conn.cursor()
                cursor.execute(sql, params)
                conn.commit()
                break
        except sqlite3.OperationalError as e:
            if "database is locked" in str(e) and attempt < attempts - 1:
                time.sleep(delay)
            else:
                raise e

# def enable_wal_mode(db_name = 'curify_ideas.db'):
#     with sqlite3.connect(db_name) as conn:
#         cursor = conn.cursor()
#         cursor.execute("PRAGMA journal_mode=WAL;")
#         conn.commit()

# # Create SQLite DB and table
# def create_db(db_name = 'curify_ideas.db'):
#     with sqlite3.connect(db_name, timeout=30) as conn:
#         c = conn.cursor()
#         c.execute('''CREATE TABLE IF NOT EXISTS sessions (
#             session_id TEXT,
#             ip_address TEXT,
#             project_desc TEXT,
#             idea_desc TEXT,
#             idea_analysis TEXT,
#             prioritization_steps TEXT,
#             timestamp DATETIME,
#             PRIMARY KEY (session_id, timestamp)
#             )
#         ''')
#         conn.commit()

# # Function to insert session data into the SQLite database
# def insert_session_data(session_id, ip_address, project_desc, idea_desc, idea_analysis, prioritization_steps, db_name = 'curify_ideas.db'):
#     execute_with_retry('''
#         INSERT INTO sessions (session_id, ip_address, project_desc, idea_desc, idea_analysis, prioritization_steps, timestamp)
#         VALUES (?, ?, ?, ?, ?, ?, ?)
#     ''', (session_id, ip_address, project_desc, idea_desc, json.dumps(idea_analysis), json.dumps(prioritization_steps), datetime.now()), db_name)


# In[11]:


def convert_to_listed_json(input_string):
    """
    Converts a string to a listed JSON object.
    
    Parameters:
        input_string (str): The JSON-like string to be converted.
    
    Returns:
        list: A JSON object parsed into a Python list of dictionaries.
    """
    try:
        # Parse the string into a Python object
        trimmed_string = input_string[input_string.index('['):input_string.rindex(']') + 1]

        json_object = json.loads(trimmed_string)
        return json_object
    except json.JSONDecodeError as e:
        return None
    return None
    #raise ValueError(f"Invalid JSON format: {e}")

def validate_and_extract_json(json_string):
    """
    Validates the JSON string, extracts fields with possible variants using fuzzy matching.
    
    Args:
    - json_string (str): The JSON string to validate and extract from.
    - field_names (list): List of field names to extract, with possible variants.
    
    Returns:
    - dict: Extracted values with the best matched field names.
    """
    # Try to parse the JSON string
    trimmed_string = json_string[json_string.index('{'):json_string.rindex('}') + 1]
    try:
        parsed_json = json.loads(trimmed_string)
        return parsed_json
    except json.JSONDecodeError as e:
        return None

    # {"error": "Parsed JSON is not a dictionary."}
    return None

def json_to_pandas(dat_json, dat_schema = {'name':"", 'description':""}):
    dat_df = pd.DataFrame([dat_schema])
    try:
        dat_df = pd.DataFrame(dat_json)

    except Exception as e:
        dat_df = pd.DataFrame([dat_schema])
    # ValueError(f"Failed to parse LLM output as JSON: {e}\nOutput: {res}")
    return dat_df


# In[12]:


client = OpenAI(
    api_key= os.environ.get("OPENAI_API_KEY"),  # This is the default and can be omitted
)

# Function to call OpenAI API with compact error handling
def call_openai_api(prompt, model="gpt-4o", max_tokens=5000, retries=3, backoff_factor=2):
    """
    Send a prompt to the OpenAI API and handle potential errors robustly.

    Parameters:
        prompt (str): The user input or task prompt to send to the model.
        model (str): The OpenAI model to use (default is "gpt-4").
        max_tokens (int): The maximum number of tokens in the response.
        retries (int): Number of retry attempts in case of transient errors.
        backoff_factor (int): Backoff time multiplier for retries.

    Returns:
        str: The model's response content if successful.
    """
    for attempt in range(1, retries + 1):
        try:
            response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=5000,
            )        
            return response.choices[0].message.content.strip()
        
        except (openai.RateLimitError, openai.APIConnectionError) as e:
            logging.warning(f"Transient error: {e}. Attempt {attempt} of {retries}. Retrying...")
        except (openai.BadRequestError, openai.AuthenticationError) as e:
            logging.error(f"Unrecoverable error: {e}. Check your inputs or API key.")
            break
        except Exception as e:
            logging.error(f"Unexpected error: {e}. Attempt {attempt} of {retries}. Retrying...")
        
        # Exponential backoff before retrying
        if attempt < retries:
            time.sleep(backoff_factor * attempt)
    
    raise RuntimeError(f"Failed to fetch response from OpenAI API after {retries} attempts.")

def fn_analyze_task(project_context, task_description):
    prompt = (
            f"You are working in the context of {project_context}. "
            f"Your task is to analyze the task: {task_description} "
            "Please analyze the following aspects: "
            "1) Determine which project this item belongs to. If the idea does not belong to any existing project, categorize it under 'Other'. "
            "2) Assess whether this idea can be treated as a concrete task. "
            "3) Evaluate whether a document can be generated as an intermediate result. "
            "4) Identify the appropriate category of the task. Possible categories are: 'Blogs/Papers', 'Tools', 'Brainstorming', 'Issues', and 'Others'. "
            "5) Extract the topic of the task. "
            "Please provide the output in JSON format using the structure below: "
            "{"
            "  \"description\": \"\", "
            "  \"project_association\": \"\", "
            "  \"is_task\": \"Yes/No\", "
            "  \"is_document\": \"Yes/No\", "
            "  \"task_category\": \"\", "
            "  \"task_topic\": \"\" "
            "}"
        )
    res_task_analysis = call_openai_api(prompt)

    try:
        json_task_analysis = validate_and_extract_json(res_task_analysis)

        return json_task_analysis
    except ValueError as e:
        logger.debug("ValueError occurred: %s", str(e), exc_info=True)  # Log the exception details
        return None


# In[13]:

# Recursive Task Executor
def fn_process_task(project_desc_table, task_description, bucket_name='curify'):
    
    project_context = project_desc_table.to_string(index=False)
    task_analysis = fn_analyze_task(project_context, task_description)

    if task_analysis:
        execution_status = []
        execution_results = task_analysis.copy()
        execution_results['deliverables'] = ''

        def traverse(node, previous_output=None):
            if not node:  # If the node is None or invalid
                return  # Exit if the node is invalid

            # Check if there is a condition to evaluate
            if "check" in node:
                # Safely attempt to retrieve the value from execution_results
                if node["check"] in execution_results:
                    value = execution_results[node["check"]]  # Evaluate the check condition
                    traverse(node.get(value, node.get("default")), previous_output)
                else:
                    # Log an error and exit, but keep partial results
                    logger.error(f"Key '{node['check']}' not found in execution_results.")
                    return
        
            # If the node contains an action
            elif "action" in node:
                action_name = node["action"]
                input_key = node.get("input", 'task_topic')

                if input_key in execution_results.keys():
                    inputs = {input_key: execution_results[input_key]}
                else:
                    # Log an error and exit, but keep partial results
                    logger.error(f"Workflow action {action_name} input key {input_key} not in execution_results.")
                    return

                logger.debug(f"Executing: {action_name} with inputs: {inputs}")
                
                # Execute the action function
                action_func = action_map.get(action_name, unsupported_task)
                try:
                    output = action_func(**inputs)
                except Exception as e:
                    # Handle action function failure
                    logger.error(f"Error executing action '{action_name}': {e}")
                    return

                # Store execution results or append to previous outputs
                execution_status.append({"action": action_name, "output": output})

                # Check if 'output' field exists in the node
                if 'output' in node:
                    # If 'output' exists, assign the output to execution_results with the key from node['output']
                    execution_results[node['output']] = output
                else:
                    # If 'output' does not exist, append the output to 'deliverables'
                    execution_results['deliverables'] += output
                
                # Traverse to the next node, if it exists
                if "next" in node and node["next"]:
                    traverse(node["next"], previous_output)

        try:
            traverse(TASK_WORKFLOW_TREE["start"])
            execution_results['doc_url'] = generate_document(task_description, execution_results)
        except Exception as e:
            logger.error(f"Traverse Error: {e}")
        finally:
            # Always return partial results, even if an error occurs
            return task_analysis, pd.DataFrame(execution_status), execution_results
    else:
        logger.error("Empty task analysis.")
        return {}, pd.DataFrame(), {}

# In[14]:


# Initialize dataframes for the schema
ideas_df = pd.DataFrame(columns=["Idea ID", "Content", "Tags"])

def extract_ideas(context, text):
    """
    Extract project ideas from text, with or without a context, and return in JSON format.

    Parameters:
        context (str): Context of the extraction. Can be empty.
        text (str): Text to extract ideas from.

    Returns:
        list: A list of ideas, each represented as a dictionary with name and description.
    """
    if context:
        # Template when context is provided
        prompt = (
            f"You are working in the context of {context}. "
            "Please extract the ongoing projects with project name and description."
            "Please only the listed JSON as output string."
            f"Ongoing projects: {text}"
        )
    else:
        # Template when context is not provided
        prompt = (
            "Given the following information about the user."
            "Please extract the ongoing projects with project name and description."
            "Please only the listed JSON as output string."
            f"Ongoing projects: {text}"
        )

    # return the raw string
    return call_openai_api(prompt)

def df_to_string(df, empty_message = ''):
    """
    Converts a DataFrame to a string if it is not empty. 
    If the DataFrame is empty, returns an empty string.
    
    Parameters:
        ideas_df (pd.DataFrame): The DataFrame to be converted.
    
    Returns:
        str: A string representation of the DataFrame or an empty string.
    """
    if df.empty:
        return empty_message
    else:
        return df.to_string(index=False)


# In[15]:


# Shared state variables
shared_state = {"project_desc_table": pd.DataFrame(), "task_analysis_txt": "", "execution_status": pd.DataFrame(), "execution_results": {}}

# Button Action: Fetch State
def fetch_updated_state():
    # Iterating and logging the shared state
    for key, value in shared_state.items():
        if isinstance(value, pd.DataFrame):
            logger.debug(f"{key}: DataFrame:\n{value.to_string()}")
        elif isinstance(value, dict):
            logger.debug(f"{key}: Dictionary: {value}")
        elif isinstance(value, str):
            logger.debug(f"{key}: String: {value}")
        else:
            logger.debug(f"{key}: Unsupported type: {value}")
    return shared_state['project_desc_table'], shared_state['task_analysis_txt'], shared_state['execution_status'], shared_state['execution_results']
    
    # response = requests.get("http://localhost:5000/state")
    # # Check the status code and the raw response
    # if response.status_code == 200:
    #     try:
    #         state = response.json()  # Try to parse JSON
    #         return pd.DataFrame(state["project_desc_table"]), state["task_analysis_txt"], pd.DataFrame(state["execution_status"]), state["execution_results"]
    #     except ValueError as e:
    #         logger.error(f"JSON decoding failed: {e}")
    #         logger.debug("Raw response body:", response.text)
    # else:
    #     logger.error(f"Error: {response.status_code} - {response.text}")
    # """Fetch the updated shared state from FastAPI."""
    # return pd.DataFrame(), "", pd.DataFrame(), {}
    

def update_gradio_state(project_desc_table, task_analysis_txt, execution_status, execution_results):
    # You can update specific components like Textbox or State
    shared_state['project_desc_table'] = project_desc_table
    shared_state['task_analysis_txt'] = task_analysis_txt
    shared_state['execution_status'] = execution_status
    shared_state['execution_results'] = execution_results
    return True


# In[16]:


# # Initialize the database
# new_db = 'curify.db'

# # Copy the old database to a new one
# shutil.copy("curify_idea.db", new_db)

#create_db(new_db)
#enable_wal_mode(new_db)
def project_extraction(project_description):

    str_projects = extract_ideas('AI-powered tools for productivity', project_description)
    json_projects = convert_to_listed_json(str_projects)

    project_desc_table = json_to_pandas(json_projects)
    update_gradio_state(project_desc_table, "", pd.DataFrame(), {})
    return project_desc_table


# In[17]:


# project_description = 'work on a number of projects including curify (digest, ideas, careers, projects etc), and writing a book on LLM for recommendation system, educating my 3.5-year-old boy and working on a paper for LLM reasoning.'

# # convert_to_listed_json(extract_ideas('AI-powered tools for productivity', project_description))

# task_description = 'Build an interview bot for the curify digest project.'
# task_analysis, reasoning_path = generate_reasoning_path(project_description, task_description)

# steps = store_and_execute_task(task_description, reasoning_path)

def message_back(task_message, execution_status, doc_url, from_whatsapp):
    # Convert task steps to a simple numbered list
    task_steps_list = "\n".join(
        [f"{i + 1}. {step['action']} - {step.get('output', '')}" for i, step in enumerate(execution_status.to_dict(orient="records"))]
    )

    # Format the body message
    body_message = (
        f"*Task Message:*\n{task_message}\n\n"
        f"*Execution Status:*\n{task_steps_list}\n\n"
        f"*Doc URL:*\n{doc_url}\n\n"
    )

    # Send response back to WhatsApp
    try:
        twillo_client.messages.create(
            from_=twilio_phone_number,
            to=from_whatsapp,
            body=body_message
        )
    except Exception as e:
        logger.error(f"Twilio Error: {e}")
        raise HTTPException(status_code=500, detail=f"Error sending WhatsApp message: {str(e)}")

    return {"status": "success"}

# Initialize the Whisper pipeline
whisper_pipeline = pipeline("automatic-speech-recognition", model="openai/whisper-medium")

# Function to transcribe audio from a media URL
def transcribe_audio_from_media_url(media_url):
    try:
        media_response = requests.get(media_url, auth=HTTPBasicAuth(account_sid, auth_token))
        # Download the media file
        media_response.raise_for_status()
        audio_data = media_response.content

        # Save the audio data to a file for processing
        audio_file_path = "temp_audio_file.mp3"
        with open(audio_file_path, "wb") as audio_file:
            audio_file.write(audio_data)

        # Transcribe the audio using Whisper
        transcription = whisper_pipeline(audio_file_path, return_timestamps=True)
        logger.debug(f"Transcription: {transcription['text']}")
        return transcription["text"]

    except Exception as e:
        logger.error(f"An error occurred: {e}")
        return None


# In[18]:


app = FastAPI()

@app.get("/state")
async def fetch_state():
    return shared_state

@app.route("/whatsapp-webhook/", methods=["POST"])
async def whatsapp_webhook(request: Request):
    form_data = await request.form()
    # Log the form data to debug
    print("Received data:", form_data)
    
    # Extract message and user information
    incoming_msg = form_data.get("Body", "").strip()
    from_number = form_data.get("From", "")
    media_url = form_data.get("MediaUrl0", "")
    media_type = form_data.get("MediaContentType0", "")

    # Initialize response variables
    transcription = None

    if media_type.startswith("audio"):
        # If the media is an audio or video file, process it
        try:
            transcription = transcribe_audio_from_media_url(media_url)
        except Exception as e:
            return JSONResponse(
                {"error": f"Failed to process voice input: {str(e)}"}, status_code=500
            )
    # Determine message content: use transcription if available, otherwise use text message
    processed_input = transcription if transcription else incoming_msg

    logger.debug(f"Processed input: {processed_input}")

    try:
        # Generate response
        project_desc_table, _ = fetch_updated_state()
        
        # If the project_desc_table is empty, return an empty JSON response
        if project_desc_table.empty:
            return JSONResponse(content={})  # Returning an empty JSON object
    
        # Continue processing if the table is not empty
        task_analysis_txt, execution_status, execution_results = fn_process_task(project_desc_table, processed_input)
        update_gradio_state(task_analysis_txt, execution_status, execution_results)
    
        doc_url = 'Fail to generate doc'
        if 'doc_url' in execution_results:
            doc_url = execution_results['doc_url']
    
        # Respond to the user on WhatsApp with the processed idea
        response = message_back(processed_input, execution_status, doc_url, from_number)
        logger.debug(response)
    
        return JSONResponse(content=str(response))
    
    except Exception as e:
        logger.error(f"Error during task processing: {e}")
        return JSONResponse(content={"error": str(e)}, status_code=500)

# In[19]:


# Mock Gmail Login Function
def mock_login(email):
    if email.endswith("@gmail.com"):
        return f"✅ Logged in as {email}", gr.update(visible=False), gr.update(visible=True)
    else:
        return "❌ Invalid Gmail address. Please try again.", gr.update(), gr.update()

# User Onboarding Function
def onboarding_survey(role, industry, project_description):
    return (project_extraction(project_description),
            gr.update(visible=False), gr.update(visible=True))

# Mock Integration Functions
def integrate_todoist():
    return "✅ Successfully connected to Todoist!"

def integrate_evernote():
    return "✅ Successfully connected to Evernote!"

def integrate_calendar():
    return "✅ Successfully connected to Google Calendar!"

def load_svg_with_size(file_path, width="600px", height="400px"):
    # Read the SVG content from the file
    with open(file_path, "r", encoding="utf-8") as file:
        svg_content = file.read()
    
    # Add inline styles to control width and height
    styled_svg = f"""
    <div style="width: {width}; height: {height}; overflow: auto;">
        {svg_content}
    </div>
    """
    return styled_svg


# In[20]:


# Gradio Demo
def create_gradio_interface(state=None):
    with gr.Blocks(
        css="""
        .gradio-table td {
            white-space: normal !important;
            word-wrap: break-word !important;
        }
        .gradio-table {
            width: 100% !important;  /* Adjust to 100% to fit the container */
            table-layout: fixed !important;  /* Fixed column widths */
            overflow-x: hidden !important;  /* Disable horizontal scrolling */
        }
        .gradio-container {
            overflow-x: hidden !important;  /* Disable horizontal scroll for entire container */
            padding: 0 !important;  /* Remove any default padding */
        }
        .gradio-column {
            max-width: 100% !important;  /* Ensure columns take up full width */
            overflow: hidden !important;  /* Hide overflow to prevent horizontal scroll */
        }
        .gradio-row {
            overflow-x: hidden !important;  /* Prevent horizontal scroll on rows */
        }
    """) as demo:

    # Page 1: Mock Gmail Login
        with gr.Group(visible=True) as login_page:
            gr.Markdown("### **1️⃣ Login with Gmail**")
            email_input = gr.Textbox(label="Enter your Gmail Address", placeholder="example@gmail.com")
            login_button = gr.Button("Login")
            login_result = gr.Textbox(label="Login Status", interactive=False, visible=False)
        # Page 2: User Onboarding
        with gr.Group(visible=False) as onboarding_page:
            gr.Markdown("### **2️⃣ Tell Us About Yourself**")
            role = gr.Textbox(label="What is your role?", placeholder="e.g. Developer, Designer")
            industry = gr.Textbox(label="Which industry are you in?", placeholder="e.g. Software, Finance")
            project_description = gr.Textbox(label="Describe your project", placeholder="e.g. A task management app")
            submit_survey = gr.Button("Submit")

        # Page 3: Mock Integrations with Separate Buttons
        with gr.Group(visible=False) as integrations_page:
            gr.Markdown("### **3️⃣ Connect Integrations**")
            gr.Markdown("Click on the buttons below to connect each tool:")

            # Separate Buttons and Results for Each Integration
            todoist_button = gr.Button("Connect to Todoist")
            todoist_result = gr.Textbox(label="Todoist Status", interactive=False, visible=False)
            
            evernote_button = gr.Button("Connect to Evernote")
            evernote_result = gr.Textbox(label="Evernote Status", interactive=False, visible=False)
            
            calendar_button = gr.Button("Connect to Google Calendar")
            calendar_result = gr.Textbox(label="Google Calendar Status", interactive=False, visible=False)

            # Skip Button to proceed directly to next page
            skip_integrations = gr.Button("Skip ➡️")
            next_button = gr.Button("Proceed to QR Code")

        with gr.Group(visible=False) as qr_code_page:
            # Page 4: QR Code and Curify Ideas
            gr.Markdown("## Curify: Unified AI Tools for Productivity")
            
            with gr.Tab("Curify Idea"):
                with gr.Row():
                    with gr.Column():
                        gr.Markdown("#### ** QR Code**")
                        # Path to your local SVG file
                        svg_file_path = "qr.svg"
                        # Load the SVG content
                        svg_content = load_svg_with_size(svg_file_path, width="200px", height="200px")
                        gr.HTML(svg_content)

                    # Column 1: Webpage rendering
                    with gr.Column():
                        
                        gr.Markdown("## Projects Overview")
                        project_desc_table = gr.DataFrame(
                            type="pandas"
                        )

                        gr.Markdown("## Enter task message.")
                        idea_input = gr.Textbox(
                            label=None,
                            placeholder="Describe the task you want to execute (e.g., Research Paper Review)")
            
                        task_btn = gr.Button("Generate Task Steps")
                        fetch_state_btn = gr.Button("Fetch Updated State")

                    with gr.Column():
                        gr.Markdown("## Task analysis")
                        task_analysis_txt = gr.Textbox(
                            label=None,
                            placeholder="Here is the execution status of your task...")

                        gr.Markdown("## Execution status")
                        execution_status = gr.DataFrame(
                            type="pandas"
                        )
                        gr.Markdown("## Execution output")
                        execution_results = gr.JSON(
                            label=None
                        )
                        state_output = gr.State()  # Add a state output to hold the state

                task_btn.click(
                    fn_process_task, 
                    inputs=[project_desc_table, idea_input], 
                    outputs=[task_analysis_txt, execution_status, execution_results]
                )

                fetch_state_btn.click(
                    fetch_updated_state, 
                    inputs=None, 
                    outputs=[project_desc_table, task_analysis_txt, execution_status, execution_results]
                )

                # Page 1 -> Page 2 Transition
                login_button.click(
                    mock_login, 
                    inputs=email_input, 
                    outputs=[login_result, login_page, onboarding_page]
                )

                # Page 2 -> Page 3 Transition (Submit and Skip)
                submit_survey.click(
                    onboarding_survey, 
                    inputs=[role, industry, project_description], 
                    outputs=[project_desc_table, onboarding_page, integrations_page]
                )

                # Integration Buttons
                todoist_button.click(integrate_todoist, outputs=todoist_result)
                evernote_button.click(integrate_evernote, outputs=evernote_result)
                calendar_button.click(integrate_calendar, outputs=calendar_result)

                # Skip Integrations and Proceed
                skip_integrations.click(
                    lambda: (gr.update(visible=False), gr.update(visible=True)),
                    outputs=[integrations_page, qr_code_page]
                )

        # # Set the load_fn to initialize the state when the page is loaded
        # demo.load(
        #     curify_ideas, 
        #     inputs=[project_input, idea_input], 
        #     outputs=[task_steps, task_analysis_txt, state_output]
        # )
    return demo
    # Load function to initialize the state
    # demo.load(load_fn, inputs=None, outputs=[state])  # Initialize the state when the page is loaded

# Function to launch Gradio
# def launch_gradio():
#     demo = create_gradio_interface()
#     demo.launch(share=True, inline=False)  # Gradio in the foreground

# # Function to run FastAPI server using uvicorn in the background
# async def run_fastapi():
#     config = uvicorn.Config(app, host="0.0.0.0", port=5000, reload=True, log_level="debug")
#     server = uvicorn.Server(config)
#     await server.serve()

# # FastAPI endpoint to display a message
# @app.get("/", response_class=HTMLResponse)
# async def index():
#     return "FastAPI is running. Visit Gradio at the provided public URL."

# # Main entry point for the asynchronous execution
# async def main():
#     # Run Gradio in the foreground and FastAPI in the background
#     loop = asyncio.get_event_loop()
    
#     # Run Gradio in a separate thread (non-blocking)
#     loop.run_in_executor(None, launch_gradio)
    
#     # Run FastAPI in the background (asynchronous)
#     await run_fastapi()

# if __name__ == "__main__":
#     import nest_asyncio
#     nest_asyncio.apply()  # Allow nested use of asyncio event loops in Jupyter notebooks
    
#     # Run the main function to launch both services concurrently
#     asyncio.run(main())
    
# In[21]:
demo = create_gradio_interface()
# Use Gradio's `server_app` to get an ASGI app for Blocks
gradio_asgi_app = demo.launch(share=False, inbrowser=False, server_name="0.0.0.0", server_port=7860, inline=False)

logging.debug(f"Gradio version: {gr.__version__}")
logging.debug(f"FastAPI version: {fastapi.__version__}")

# # Mount the Gradio ASGI app at "/gradio"
# app.mount("/gradio", gradio_asgi_app)

# # create a static directory to store the static files
# static_dir = Path('./static')
# static_dir.mkdir(parents=True, exist_ok=True)

# # mount FastAPI StaticFiles server
# app.mount("/static", StaticFiles(directory=static_dir), name="static")

# Dynamically check for the Gradio asset directory
# gradio_assets_path = os.path.join(os.path.dirname(gr.__file__), "static")

# if os.path.exists(gradio_assets_path):
#     # If assets exist, mount them
#     app.mount("/assets", StaticFiles(directory=gradio_assets_path), name="assets")
# else:
#     logging.error(f"Gradio assets directory not found at: {gradio_assets_path}")

# Redirect from the root endpoint to the Gradio app
@app.get("/", response_class=RedirectResponse)
async def index():
    return RedirectResponse(url="/gradio", status_code=307)

# Run the FastAPI server using uvicorn
if __name__ == "__main__":
    # port = int(os.getenv("PORT", 5000))  # Default to 7860 if PORT is not set
    uvicorn.run(app, host="0.0.0.0", port=7860)