#!/usr/bin/env python3
"""
Hybrid Reasoning Bot
-------------------
A bot that chooses between RAG or general LLM answers based on similarity score.
It uses your indexed documents when it finds relevant information,
and falls back to general knowledge when necessary.
"""

import argparse
import numpy as np
from hands-on-ai.chat import get_response
from hands-on-ai.rag.utils import embed_query, get_top_k
import os
import time

# Emoji constants
RAG_TAG = "🧠"  # Knowledge from your notes/documents
LLM_TAG = "🌐"  # Knowledge from the model's training

def load_index(index_path):
    """Load the index from an .npz file"""
    try:
        data = np.load(index_path, allow_pickle=True)
        chunks = data['chunks']
        embeddings = data['embeddings']
        metadata = data.get('metadata', None)
        return chunks, embeddings, metadata
    except Exception as e:
        print(f"Error loading index: {e}")
        exit(1)

def get_chunks_with_scores(query, chunks, embeddings, top_k=3):
    """Retrieve the most relevant chunks and their similarity scores for a query"""
    # Embed the query
    query_embedding = embed_query(query)

    # Get top chunks with scores
    top_chunks, top_scores, top_indices = get_top_k(
        query_embedding, embeddings, chunks, k=top_k, return_indices=True
    )

    return top_chunks, top_scores, top_indices

def generate_rag_answer(query, chunks):
    """Generate an answer using RAG with the provided chunks as context"""
    context = "\n\n---\n\n".join(chunks)

    prompt = f"""
Based on the following information, please answer the question.
If the information doesn't fully address the question, use only what's relevant.

Context:
{context}

Question: {query}

Answer:
"""
    return get_response(prompt, personality="helpful")

def generate_llm_answer(query):
    """Generate an answer using only the LLM's general knowledge"""
    prompt = f"""
Please answer this question based on your general knowledge:

Question: {query}

Answer:
"""
    return get_response(prompt, personality="helpful")

def main():
    parser = argparse.ArgumentParser(description="Hybrid reasoning bot using RAG and general knowledge")
    parser.add_argument("query", help="The question to ask")
    parser.add_argument("--index", "-i", default="sample_index.npz", help="Path to the .npz index file")
    parser.add_argument("--threshold", "-t", type=float, default=0.7, 
                        help="Similarity score threshold for using RAG (0.0-1.0)")
    parser.add_argument("--top-k", "-k", type=int, default=3, 
                        help="Number of chunks to use when generating RAG answers")
    parser.add_argument("--no-fallback", "-n", action="store_true", 
                        help="Disable fallback to general knowledge even with low scores")
    parser.add_argument("--compare", "-c", action="store_true", 
                        help="Show both RAG and general knowledge answers for comparison")
    parser.add_argument("--show-scores", "-s", action="store_true", 
                        help="Show similarity scores for retrieved chunks")
    args = parser.parse_args()

    # Load the index
    print(f"Loading index from {args.index}...")
    chunks, embeddings, metadata = load_index(args.index)
    print(f"Loaded {len(chunks)} chunks from index.")

    # Get relevant chunks and their scores
    top_chunks, top_scores, top_indices = get_chunks_with_scores(
        args.query, chunks, embeddings, top_k=args.top_k
    )

    # Determine if we should use RAG based on the highest similarity score
    best_score = max(top_scores) if top_scores else 0
    use_rag = best_score >= args.threshold

    # Show scores if requested
    if args.show_scores:
        print("\n=== Similarity Scores ===")
        for i, (chunk, score) in enumerate(zip(top_chunks, top_scores)):
            print(f"[{i+1}] Score: {score:.4f}")
            print(f"Preview: {chunk[:100]}...\n")
        print(f"Best score: {best_score:.4f} (Threshold: {args.threshold})")
        print(f"Decision: {'Using RAG' if use_rag else 'Using general knowledge'}\n")

    # Generate answers
    if args.compare:
        # Generate both answers for comparison
        print("\n=== Generating both answers for comparison ===")

        print(f"\n{RAG_TAG} Generating answer from your documents...")
        rag_answer = generate_rag_answer(args.query, top_chunks)

        print(f"\n{LLM_TAG} Generating answer from general knowledge...")
        llm_answer = generate_llm_answer(args.query)

        # Display both answers
        print(f"\n=== {RAG_TAG} Answer from your documents ===")
        print(rag_answer)

        print(f"\n=== {LLM_TAG} Answer from general knowledge ===")
        print(llm_answer)

    else:
        # Generate only one answer based on the threshold
        if use_rag or args.no_fallback:
            tag = RAG_TAG
            print(f"\n{tag} Generating answer from your documents...")
            answer = generate_rag_answer(args.query, top_chunks)
        else:
            tag = LLM_TAG
            print(f"\n{tag} No sufficiently relevant information found in your documents.")
            print(f"{tag} Falling back to general knowledge...")
            answer = generate_llm_answer(args.query)

        # Display the answer
        print(f"\n=== {tag} Answer ===")
        print(answer)

    # Show sources if using RAG
    if (use_rag or args.no_fallback or args.compare) and metadata is not None:
        print("\n=== Sources ===")
        used_sources = set()
        for idx in top_indices:
            source = metadata[idx].get('source', 'unknown')
            used_sources.add(source)

        for source in used_sources:
            print(f"- {source}")

if __name__ == "__main__":
    main()

   # Embed the query
   query_embedding = embed_query(query)

   # Get the top k chunks and their similarity scores
   top_chunks, top_scores, top_indices = get_top_k(
       query_embedding, embeddings, chunks, k=top_k, return_indices=True
   )

   # Prepare context from top chunks
   context = "\n\n---\n\n".join(top_chunks)

   # Show scores and sources if requested
   if show_scores:
       print("\n=== Top Chunks ===")
       for i, (chunk, score) in enumerate(zip(top_chunks, top_scores)):
           source_info = ""
           if metadata is not None and len(metadata) > top_indices[i]:
               source_info = f" Source: {metadata[top_indices[i]].get('source', 'unknown')}"
           print(f"[{i+1}] Score: {score:.4f}{source_info}")
           print(f"Preview: {chunk[:100]}...\n")

   return context, top_chunks, top_scores

   # Load the index
   chunks, embeddings, metadata = load_index(args.index)

   # Query the index
   context, top_chunks, top_scores = query_index(
       args.query, chunks, embeddings, metadata, 
       top_k=args.top_k, show_scores=args.show_scores
   )

   # Show full context if requested
   if args.show_context:
       print("\n=== Full Context ===")
       print(context)
       print("\n")

   # Generate and print the answer
   print("\n=== Answer ===")
   answer = generate_answer(args.query, context)
   print(answer)

   # Log source information if metadata is available
   if metadata is not None and not args.show_scores:
       print("\n=== Sources ===")
       used_sources = set()
       for idx in range(min(args.top_k, len(top_chunks))):
           if idx < len(top_scores):
               source = metadata[idx].get('source', 'unknown')
               used_sources.add(source)

       for source in used_sources:
           print(f"- {source}")

import os
import sys
import fitz  # PyMuPDF
from hands-on-ai.chat import get_response

class PDFChatbot:
    """A chatbot that can answer questions about PDF documents."""

    def __init__(self):
        self.pdf_file = None
        self.pdf_text = ""
        self.context_size = 5000  # Max context size to send to the AI

    def load_pdf(self, file_path):
        """Load and extract text from a PDF file."""
        try:
            if not os.path.exists(file_path):
                print(f"Error: File '{file_path}' not found.")
                return False

            self.pdf_file = file_path

            # Open the PDF
            doc = fitz.open(file_path)

            # Extract text from all pages
            full_text = []
            for page_num in range(len(doc)):
                page = doc.load_page(page_num)
                full_text.append(page.get_text())

            self.pdf_text = "\n".join(full_text)

            # Print document stats
            print(f"\nDocument loaded: {os.path.basename(file_path)}")
            print(f"Number of pages: {len(doc)}")
            print(f"Total characters: {len(self.pdf_text)}")

            # Print a preview
            preview_length = min(200, len(self.pdf_text))
            print(f"\nPreview:\n{self.pdf_text[:preview_length]}...")

            return True

        except Exception as e:
            print(f"Error loading PDF: {e}")
            return False

    def summarize_document(self):
        """Generate a summary of the document."""
        if not self.pdf_text:
            print("Error: No document loaded. Please load a PDF first.")
            return

        print("\nGenerating document summary...")

        # Create a prompt for the AI
        prompt = f"""
        Please provide a concise summary of the following document:

        {self.pdf_text[:5000]}  # Send only the first part if the document is large

        Include:
        1. Main topics and themes
        2. Key points or arguments
        3. Important entities mentioned
        4. Document structure overview

        Keep the summary under 300 words.
        """

        try:
            summary = get_response(prompt)
            print("\n=== Document Summary ===")
            print(summary)
        except Exception as e:
            print(f"Error generating summary: {e}")

    def answer_question(self, question):
        """Answer a question about the document."""
        if not self.pdf_text:
            print("Error: No document loaded. Please load a PDF first.")
            return

        if not question:
            print("Error: No question provided.")
            return

        print(f"\nAnswering: {question}")

        # Create a prompt for the AI
        prompt = f"""
        Document text:
        {self.pdf_text[:self.context_size]}

        Question: {question}

        Please answer the question based only on the information provided in the document.
        If the answer cannot be found in the document, state that clearly.
        Provide page numbers or sections if you can determine them from the context.
        """

        try:
            answer = get_response(prompt)
            print("\n=== Answer ===")
            print(answer)
        except Exception as e:
            print(f"Error generating answer: {e}")

    def extract_key_information(self):
        """Extract key information from the document."""
        if not self.pdf_text:
            print("Error: No document loaded. Please load a PDF first.")
            return

        print("\nExtracting key information...")

        # Create a prompt for the AI
        prompt = f"""
        Please extract and organize key information from this document:

        {self.pdf_text[:self.context_size]}

        Extract the following (if present):
        1. Dates and deadlines
        2. Names and organizations
        3. Numerical data or statistics
        4. Definitions or technical terms
        5. Action items or requirements

        Format the information in clear categories with brief explanations.
        """

        try:
            key_info = get_response(prompt)
            print("\n=== Key Information ===")
            print(key_info)
        except Exception as e:
            print(f"Error extracting information: {e}")

    def find_related_topics(self, topic):
        """Find information related to a specific topic in the document."""
        if not self.pdf_text:
            print("Error: No document loaded. Please load a PDF first.")
            return

        if not topic:
            print("Error: No topic provided.")
            return

        print(f"\nFinding information related to: {topic}")

        # Create a prompt for the AI
        prompt = f"""
        Document text:
        {self.pdf_text[:self.context_size]}

        Please find and extract all information related to the topic "{topic}" from the document.
        Include any definitions, explanations, examples, or references related to this topic.
        Organize the information in a structured way and indicate where in the document it appears if possible.
        If the topic is not mentioned in the document, please state that clearly.
        """

        try:
            related_info = get_response(prompt)
            print(f"\n=== Information Related to '{topic}' ===")
            print(related_info)
        except Exception as e:
            print(f"Error finding related information: {e}")

    def run(self):
        """Run the PDF chatbot interface."""
        print("=== PDF Question Answering Chatbot ===")
        print("This chatbot can answer questions about PDF documents.")

        while True:
            print("\nOptions:")
            print("1. Load a PDF document")
            print("2. Get document summary")
            print("3. Ask a question")
            print("4. Extract key information")
            print("5. Find related topics")
            print("6. Exit")

            choice = input("\nSelect an option (1-6): ")

            if choice == '1':
                # Load PDF
                file_path = input("\nEnter the path to a PDF file: ")
                self.load_pdf(file_path)

            elif choice == '2':
                # Summarize document
                self.summarize_document()

            elif choice == '3':
                # Ask a question
                if not self.pdf_text:
                    print("Please load a PDF document first (option 1).")
                    continue

                question = input("\nEnter your question about the document: ")
                self.answer_question(question)

            elif choice == '4':
                # Extract key information
                self.extract_key_information()

            elif choice == '5':
                # Find related topics
                if not self.pdf_text:
                    print("Please load a PDF document first (option 1).")
                    continue

                topic = input("\nEnter a topic to find in the document: ")
                self.find_related_topics(topic)

            elif choice == '6':
                # Exit
                print("\nExiting PDF Chatbot. Goodbye!")
                break

            else:
                print("Invalid choice. Please select a number between 1 and 6.")

# Run the chatbot
if __name__ == "__main__":
    chatbot = PDFChatbot()
    chatbot.run()

from hands-on-ai.agent import run_agent, register_tool

# Define a calculator function
def calculator(expression):
    """Evaluate a mathematical expression."""
    try:
        # Using a safe eval environment
        result = eval(expression, {"__builtins__": {}}, {
            "abs": abs, "min": min, "max": max, "round": round, 
            "sum": sum, "pow": pow, "int": int, "float": float
        })
        return f"Result: {result}"
    except Exception as e:
        return f"Error: {str(e)}"

# Register the calculator tool
register_tool(
    "calculator", 
    "Evaluate a mathematical expression. Example: 2 + 2 * 10", 
    calculator
)

# Create a function to run the agent
def solve_math_problem(question):
    """Solve a math problem using the agent."""
    print(f"Question: {question}")

    # Run the agent with the question
    response = run_agent(question, verbose=True)

    print("\nFinal Answer:")
    print(response)

    return response

# Example usage
if __name__ == "__main__":
    questions = [
        "What is 25 * 3?",
        "If I have 125 apples and give away 1/5 of them, how many do I have left?",
        "What is the square root of 144?",
        "What is 15% of 240?",
        "If a triangle has sides of length 3, 4, and 5, what is its area?"
    ]

    for q in questions:
        print("\n" + "="*50)
        solve_math_problem(q)
        print("="*50)

==================================================
Question: What is 25 * 3?

Thought: I need to multiply 25 by 3. I can use the calculator tool for this.
Action: calculator
Action Input: 25 * 3
Observation: Result: 75

Final Answer: The result of 25 * 3 is 75.
==================================================

from hands-on-ai.chat import get_response
import datetime
import os

def reflection_journal():
    print("=== Personal Reflection Journal ===")
    print("Use this bot to keep track of your thoughts and receive insights.")
    print("Type 'exit' at any time to quit.\n")

    # Create a list to store journal entries
    memory = []

    # Create a simple file-based storage system
    journal_file = "journal_entries.txt"

    # Load previous entries if file exists
    if os.path.exists(journal_file):
        try:
            with open(journal_file, 'r') as f:
                previous_entries = f.read().strip()
                if previous_entries:
                    print("Found previous journal entries.")
                    restore = input("Would you like to include them in today's reflection? (yes/no): ").lower()
                    if restore == "yes":
                        memory.append(previous_entries)
                        print("Previous entries loaded.")
        except Exception as e:
            print(f"Error loading previous entries: {e}")

    # Main journaling loop
    num_entries = int(input("How many things would you like to reflect on today? (1-5): "))
    num_entries = min(max(1, num_entries), 5)  # Ensure between 1 and 5

    for i in range(num_entries):
        print(f"\n--- Entry {i+1}/{num_entries} ---")

        # Prompt options
        prompts = [
            "What's something that happened today that you'd like to reflect on?",
            "What's something you learned today?",
            "What's something you're grateful for today?",
            "What's something that challenged you today?",
            "What's something you're looking forward to?"
        ]

        # Let user choose a prompt or write their own
        print("Choose a prompt or create your own:")
        for j, prompt in enumerate(prompts, 1):
            print(f"{j}. {prompt}")
        print(f"{len(prompts) + 1}. Write my own prompt")

        prompt_choice = input("\nEnter choice (1-6): ")

        # Exit condition
        if prompt_choice.lower() == "exit":
            break

        # Get the prompt
        try:
            choice_num = int(prompt_choice)
            if 1 <= choice_num <= len(prompts):
                selected_prompt = prompts[choice_num - 1]
            else:
                selected_prompt = input("Enter your custom prompt: ")
        except ValueError:
            selected_prompt = prompts[0]  # Default to first prompt if invalid input

        # Get the journal entry
        print(f"\n{selected_prompt}")
        entry = input("> ")

        # Exit condition
        if entry.lower() == "exit":
            break

        # Record the timestamp and add to memory
        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
        full_entry = f"[{timestamp}] {selected_prompt}\n{entry}"
        memory.append(full_entry)

        # Give immediate reflection
        if i < num_entries - 1:  # Only for entries except the last one
            reflection = get_response(
                f"The user wrote this journal entry: {entry}\n\nGive a brief, thoughtful response that might help them reflect deeper.",
                system="You are a supportive journaling assistant. Respond with 1-2 sentences that are empathetic and thought-provoking, but not advice-giving."
            )
            print("\nReflection:")
            print(reflection)

    # If we have entries, save them and provide insights
    if memory:
        # Save entries to file
        try:
            with open(journal_file, 'a') as f:
                for entry in memory:
                    f.write(entry + "\n\n")
            print("\nJournal entries saved.")
        except Exception as e:
            print(f"Error saving entries: {e}")

        # Combine all entries for analysis
        all_entries = "\n\n".join(memory)

        # Generate insights
        print("\n=== Journal Insights ===")
        insights = get_response(
            f"Here are the user's journal entries:\n\n{all_entries}\n\nProvide thoughtful insights about these reflections.",
            system="You are an insightful journaling assistant. Analyze these entries for patterns, themes, or notable elements. Provide 3-4 helpful observations that might help the user understand their thoughts better. Be supportive and thoughtful."
        )

        print(insights)

        # Offer a follow-up question
        print("\n=== Reflection Question ===")
        question = get_response(
            f"Based on these journal entries:\n\n{all_entries}\n\nProvide one thoughtful question that would help the user reflect more deeply.",
            system="You are a reflective journaling coach. Create one open-ended, thought-provoking question that will help the user explore their thoughts more deeply. The question should be specific to the content of their entries."
        )

        print(question)
    else:
        print("No journal entries were recorded.")

# Run the reflection journal
if __name__ == "__main__":
    reflection_journal()

import requests
import matplotlib.pyplot as plt
import os
from datetime import datetime, timedelta
from hands-on-ai.chat import get_response

class WeatherDashboard:
    """
    A simple weather dashboard that retrieves and displays weather data.
    Students will need to sign up for a free API key from OpenWeatherMap.
    """

    def __init__(self):
        self.api_key = None
        self.base_url = "https://api.openweathermap.org/data/2.5/"
        self.output_dir = "weather_dashboard"
        os.makedirs(self.output_dir, exist_ok=True)

    def setup(self):
        """Set up the dashboard with the API key."""
        print("=== Weather Dashboard Setup ===")

        # Check for existing API key
        key_file = os.path.join(self.output_dir, "api_key.txt")
        if os.path.exists(key_file):
            with open(key_file, 'r') as f:
                self.api_key = f.read().strip()
            print("API key loaded from file.")

        # If no API key, prompt for one
        if not self.api_key:
            print("\nYou need an OpenWeatherMap API key to use this dashboard.")
            print("Get a free API key at: https://openweathermap.org/api")
            self.api_key = input("Enter your API key: ").strip()

            # Save API key for future use
            save_key = input("Save this API key for future use? (y/n): ").lower() == 'y'
            if save_key:
                with open(key_file, 'w') as f:
                    f.write(self.api_key)
                print("API key saved.")

    def get_current_weather(self, location):
        """Get current weather for a location."""
        url = f"{self.base_url}weather"
        params = {
            'q': location,
            'appid': self.api_key,
            'units': 'metric'  # Use metric by default
        }

        try:
            response = requests.get(url, params=params)
            response.raise_for_status()  # Raise exception for HTTP errors
            return response.json()
        except requests.exceptions.HTTPError as http_err:
            if response.status_code == 404:
                print(f"Location '{location}' not found. Please check the spelling.")
            else:
                print(f"HTTP error: {http_err}")
            return None
        except Exception as err:
            print(f"Error: {err}")
            return None

    def get_forecast(self, location, days=5):
        """Get weather forecast for a location."""
        url = f"{self.base_url}forecast"
        params = {
            'q': location,
            'appid': self.api_key,
            'units': 'metric',
            'cnt': days * 8  # API returns data in 3-hour steps, 8 per day
        }

        try:
            response = requests.get(url, params=params)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as http_err:
            if response.status_code == 404:
                print(f"Location '{location}' not found. Please check the spelling.")
            else:
                print(f"HTTP error: {http_err}")
            return None
        except Exception as err:
            print(f"Error: {err}")
            return None

    def display_current_weather(self, data):
        """Display current weather conditions."""
        if not data:
            return

        try:
            city = data['name']
            country = data['sys']['country']
            temp = data['main']['temp']
            feels_like = data['main']['feels_like']
            humidity = data['main']['humidity']
            pressure = data['main']['pressure']
            weather_desc = data['weather'][0]['description']
            wind_speed = data['wind']['speed']
            clouds = data['clouds']['all']

            # Convert Unix timestamp to readable format
            sunrise = datetime.fromtimestamp(data['sys']['sunrise']).strftime('%H:%M')
            sunset = datetime.fromtimestamp(data['sys']['sunset']).strftime('%H:%M')

            print("\n=== Current Weather Conditions ===")
            print(f"Location: {city}, {country}")
            print(f"Weather: {weather_desc.title()}")
            print(f"Temperature: {temp}°C (Feels like: {feels_like}°C)")
            print(f"Humidity: {humidity}%")
            print(f"Pressure: {pressure} hPa")
            print(f"Wind Speed: {wind_speed} m/s")
            print(f"Cloud Cover: {clouds}%")
            print(f"Sunrise: {sunrise}")
            print(f"Sunset: {sunset}")

        except KeyError as e:
            print(f"Error parsing weather data: {e}")

    def plot_forecast(self, data, location):
        """Create forecast plots and save them."""
        if not data:
            return

        try:
            # Extract forecast data
            timestamps = []
            temps = []
            humidity = []
            descriptions = []

            for item in data['list']:
                dt = datetime.fromtimestamp(item['dt'])
                timestamps.append(dt)
                temps.append(item['main']['temp'])
                humidity.append(item['main']['humidity'])
                descriptions.append(item['weather'][0]['description'])

            # Create temperature forecast plot
            plt.figure(figsize=(12, 6))
            plt.plot(timestamps, temps, marker='o', color='#FF5733', linewidth=2)
            plt.xlabel('Date & Time')
            plt.ylabel('Temperature (°C)')
            plt.title(f'Temperature Forecast for {location}')
            plt.grid(True, linestyle='--', alpha=0.7)
            plt.xticks(rotation=45)
            plt.tight_layout()

            # Save the plot
            temp_plot_file = os.path.join(self.output_dir, f"{location.replace(',', '_')}_temp_forecast.png")
            plt.savefig(temp_plot_file)
            plt.close()

            # Create humidity forecast plot
            plt.figure(figsize=(12, 6))
            plt.plot(timestamps, humidity, marker='s', color='#3498DB', linewidth=2)
            plt.xlabel('Date & Time')
            plt.ylabel('Humidity (%)')
            plt.title(f'Humidity Forecast for {location}')
            plt.grid(True, linestyle='--', alpha=0.7)
            plt.xticks(rotation=45)
            plt.tight_layout()

            # Save the plot
            humidity_plot_file = os.path.join(self.output_dir, f"{location.replace(',', '_')}_humidity_forecast.png")
            plt.savefig(humidity_plot_file)
            plt.close()

            print(f"\nForecast plots saved to:\n- {temp_plot_file}\n- {humidity_plot_file}")

            return temp_plot_file, humidity_plot_file

        except KeyError as e:
            print(f"Error parsing forecast data: {e}")
            return None, None

    def get_weather_summary(self, current_data, forecast_data, location):
        """Generate a summary of the weather conditions and forecast."""
        if not current_data or not forecast_data:
            return "Unable to generate weather summary due to missing data."

        try:
            # Extract key information
            current_temp = current_data['main']['temp']
            current_desc = current_data['weather'][0]['description']

            # Get min/max for the next few days
            daily_temps = {}
            for item in forecast_data['list']:
                dt = datetime.fromtimestamp(item['dt'])
                date_str = dt.strftime('%Y-%m-%d')

                if date_str not in daily_temps:
                    daily_temps[date_str] = {'temps': [], 'descs': []}

                daily_temps[date_str]['temps'].append(item['main']['temp'])
                daily_temps[date_str]['descs'].append(item['weather'][0]['description'])

            # Create summary with key info
            summary = f"Weather Summary for {location}:\n\n"
            summary += f"Current Conditions: {current_desc.title()} at {current_temp}°C\n\n"
            summary += "Forecast:\n"

            for date_str, data in daily_temps.items():
                if data['temps']:  # Make sure we have data
                    min_temp = min(data['temps'])
                    max_temp = max(data['temps'])

                    # Get most common description
                    from collections import Counter
                    desc_counter = Counter(data['descs'])
                    most_common_desc = desc_counter.most_common(1)[0][0]

                    # Format date nicely (e.g., "Monday, Jan 15")
                    date_obj = datetime.strptime(date_str, '%Y-%m-%d')
                    formatted_date = date_obj.strftime('%A, %b %d')

                    summary += f"- {formatted_date}: {most_common_desc.title()}, {min_temp}°C to {max_temp}°C\n"

            return summary

        except KeyError as e:
            print(f"Error generating weather summary: {e}")
            return "Unable to generate weather summary."

    def get_ai_weather_advice(self, current_data, forecast_data, location):
        """Get AI-generated weather advice based on conditions."""
        if not current_data or not forecast_data:
            return "Unable to generate weather advice due to missing data."

        try:
            # Prepare weather information for the AI
            current_temp = current_data['main']['temp']
            current_desc = current_data['weather'][0]['description']
            current_humidity = current_data['main']['humidity']
            current_wind = current_data['wind']['speed']

            # Extract forecast information
            tomorrow_data = forecast_data['list'][:8]  # First 8 entries (24 hours)
            tomorrow_descs = [item['weather'][0]['description'] for item in tomorrow_data]
            tomorrow_temps = [item['main']['temp'] for item in tomorrow_data]

            avg_tomorrow_temp = sum(tomorrow_temps) / len(tomorrow_temps)
            min_tomorrow_temp = min(tomorrow_temps)
            max_tomorrow_temp = max(tomorrow_temps)

            # Create prompt for AI
            prompt = f"""
            Based on the following weather data for {location}:

            Current conditions:
            - Temperature: {current_temp}°C
            - Description: {current_desc}
            - Humidity: {current_humidity}%
            - Wind speed: {current_wind} m/s

            Tomorrow's forecast:
            - Average temperature: {avg_tomorrow_temp:.1f}°C
            - Range: {min_tomorrow_temp:.1f}°C to {max_tomorrow_temp:.1f}°C
            - Conditions: {', '.join(set(tomorrow_descs))}

            Please provide:
            1. Practical advice for what to wear or prepare for today
            2. Any weather warnings or precautions to be aware of
            3. Suggested activities that would be appropriate for this weather

            Keep your response conversational and under 150 words.
            """

            try:
                advice = get_response(prompt)
                return advice
            except Exception as e:
                print(f"Error getting AI weather advice: {e}")
                return "Unable to generate AI weather advice at this time."

        except KeyError as e:
            print(f"Error preparing data for AI advice: {e}")
            return "Unable to generate weather advice due to missing data."

    def run(self):
        """Run the main dashboard interface."""
        self.setup()

        if not self.api_key:
            print("No API key provided. Exiting.")
            return

        print("\n=== Weather Dashboard ===")
        location = input("Enter a city name (e.g., 'London' or 'London,UK'): ")

        print(f"\nFetching weather data for {location}...")
        current_data = self.get_current_weather(location)

        if current_data:
            self.display_current_weather(current_data)

            # Get forecast data
            print("\nFetching forecast data...")
            forecast_data = self.get_forecast(location)

            if forecast_data:
                # Plot forecast
                temp_plot, humidity_plot = self.plot_forecast(forecast_data, location)

                # Generate weather summary
                summary = self.get_weather_summary(current_data, forecast_data, location)
                print("\n=== Weather Summary ===")
                print(summary)

                # Get AI advice if requested
                get_advice = input("\nWould you like personalized weather advice? (y/n): ").lower() == 'y'
                if get_advice:
                    print("\nGenerating advice...")
                    advice = self.get_ai_weather_advice(current_data, forecast_data, location)
                    print("\n=== Weather Advice ===")
                    print(advice)

                # Save all info to a report file
                save_report = input("\nSave a weather report file? (y/n): ").lower() == 'y'
                if save_report:
                    try:
                        report_file = os.path.join(self.output_dir, f"{location.replace(',', '_')}_weather_report.txt")
                        with open(report_file, 'w') as f:
                            f.write(f"Weather Report for {location}\n")
                            f.write(f"Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n\n")
                            f.write("=== Current Conditions ===\n")

                            # Extract current conditions
                            f.write(f"Temperature: {current_data['main']['temp']}°C\n")
                            f.write(f"Feels like: {current_data['main']['feels_like']}°C\n")
                            f.write(f"Weather: {current_data['weather'][0]['description'].title()}\n")
                            f.write(f"Humidity: {current_data['main']['humidity']}%\n")
                            f.write(f"Wind speed: {current_data['wind']['speed']} m/s\n")
                            f.write(f"Pressure: {current_data['main']['pressure']} hPa\n\n")

                            # Add summary
                            f.write("=== Forecast Summary ===\n")
                            f.write(summary + "\n\n")

                            # Add advice if it was generated
                            if get_advice:
                                f.write("=== Weather Advice ===\n")
                                f.write(advice + "\n")

                            # Add note about plot files
                            if temp_plot and humidity_plot:
                                f.write("\nForecast plots saved as:\n")
                                f.write(f"- {os.path.basename(temp_plot)}\n")
                                f.write(f"- {os.path.basename(humidity_plot)}\n")

                        print(f"\nWeather report saved to: {report_file}")
                    except Exception as e:
                        print(f"Error saving weather report: {e}")

        print("\nThank you for using the Weather Dashboard!")

# Run the dashboard
if __name__ == "__main__":
    dashboard = WeatherDashboard()
    dashboard.run()

from hands-on-ai.chat import get_response
import pandas as pd
import matplotlib.pyplot as plt
from io import BytesIO
import base64
import random
import os
import numpy as np

def data_dashboard():
    """Interactive data visualization dashboard for exploring datasets"""

    # Sample dataset (students could replace with their own CSV)
    sample_data = {
        'Month': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
        'Temperature': [12, 14, 16, 19, 22, 25, 27, 26, 23, 19, 15, 13],
        'Rainfall': [50, 45, 35, 30, 25, 15, 10, 12, 20, 35, 40, 48],
        'Visitors': [120, 135, 190, 240, 310, 430, 590, 560, 420, 320, 190, 150]
    }

    # Create a DataFrame from the sample data
    df = pd.DataFrame(sample_data)

    print("=== Data Visualization Dashboard ===")
    print("This dashboard allows you to explore relationships in data.")

    # Create directory for plots if it doesn't exist
    plots_dir = "dashboard_plots"
    os.makedirs(plots_dir, exist_ok=True)

    while True:
        print("\nOptions:")
        print("1. View data summary")
        print("2. Line chart")
        print("3. Bar chart")
        print("4. Scatter plot")
        print("5. Get AI insights")
        print("6. Exit")

        choice = input("\nSelect an option (1-6): ")

        if choice == '1':
            # Data summary
            print("\n=== Data Summary ===")
            print(f"Dataset shape: {df.shape[0]} rows, {df.shape[1]} columns")
            print("\nColumns:")
            for column in df.columns:
                print(f"- {column}")

            print("\nSummary statistics:")
            print(df.describe())

            print("\nFirst few rows:")
            print(df.head())

        elif choice == '2':
            # Line chart
            print("\n=== Line Chart ===")
            print("Available columns:")
            for i, column in enumerate(df.columns[1:], 1):  # Skip 'Month' column
                print(f"{i}. {column}")

            column_idx = int(input("\nSelect column to plot (1-3): ")) - 1
            column_to_plot = df.columns[column_idx + 1]  # +1 to account for skipping 'Month'

            plt.figure(figsize=(10, 6))
            plt.plot(df['Month'], df[column_to_plot], marker='o', linewidth=2)
            plt.title(f'{column_to_plot} by Month')
            plt.xlabel('Month')
            plt.ylabel(column_to_plot)
            plt.grid(True, linestyle='--', alpha=0.7)

            # Save plot to file
            plot_filename = os.path.join(plots_dir, f"line_{column_to_plot.lower()}.png")
            plt.savefig(plot_filename)
            plt.close()

            print(f"\nLine chart created and saved as {plot_filename}")

        elif choice == '3':
            # Bar chart
            print("\n=== Bar Chart ===")
            print("Available columns:")
            for i, column in enumerate(df.columns[1:], 1):  # Skip 'Month' column
                print(f"{i}. {column}")

            column_idx = int(input("\nSelect column to plot (1-3): ")) - 1
            column_to_plot = df.columns[column_idx + 1]  # +1 to account for skipping 'Month'

            plt.figure(figsize=(10, 6))
            plt.bar(df['Month'], df[column_to_plot], color='skyblue', edgecolor='navy')
            plt.title(f'{column_to_plot} by Month')
            plt.xlabel('Month')
            plt.ylabel(column_to_plot)
            plt.grid(True, axis='y', linestyle='--', alpha=0.7)

            # Save plot to file
            plot_filename = os.path.join(plots_dir, f"bar_{column_to_plot.lower()}.png")
            plt.savefig(plot_filename)
            plt.close()

            print(f"\nBar chart created and saved as {plot_filename}")

        elif choice == '4':
            # Scatter plot
            print("\n=== Scatter Plot ===")
            print("Available columns for X-axis:")
            for i, column in enumerate(df.columns[1:], 1):  # Skip 'Month' column
                print(f"{i}. {column}")

            x_idx = int(input("\nSelect X-axis column (1-3): ")) - 1
            x_column = df.columns[x_idx + 1]  # +1 to account for skipping 'Month'

            print("\nAvailable columns for Y-axis:")
            for i, column in enumerate(df.columns[1:], 1):  # Skip 'Month' column
                if column != x_column:  # Don't show the X column again
                    print(f"{i}. {column}")

            y_idx = int(input("\nSelect Y-axis column (1-3): ")) - 1
            y_column = df.columns[y_idx + 1]  # +1 to account for skipping 'Month'

            plt.figure(figsize=(10, 6))
            plt.scatter(df[x_column], df[y_column], color='purple', alpha=0.7, s=100)

            # Add month labels to each point
            for i, month in enumerate(df['Month']):
                plt.annotate(month, (df[x_column][i], df[y_column][i]), 
                             xytext=(5, 5), textcoords='offset points')

            plt.title(f'{y_column} vs {x_column}')
            plt.xlabel(x_column)
            plt.ylabel(y_column)
            plt.grid(True, linestyle='--', alpha=0.7)

            # Optional: Add trendline
            plt.plot(np.unique(df[x_column]), 
                     np.poly1d(np.polyfit(df[x_column], df[y_column], 1))(np.unique(df[x_column])),
                     color='red', linestyle='--', alpha=0.7)

            # Save plot to file
            plot_filename = os.path.join(plots_dir, f"scatter_{x_column.lower()}_{y_column.lower()}.png")
            plt.savefig(plot_filename)
            plt.close()

            print(f"\nScatter plot created and saved as {plot_filename}")

        elif choice == '5':
            # AI insights
            print("\n=== AI Data Insights ===")

            try:
                # Prepare data summary for AI
                data_description = f"""
                Dataset with columns: {', '.join(df.columns)}
                Summary statistics:
                {df.describe().to_string()}

                First few rows:
                {df.head().to_string()}
                """

                insight_prompt = f"""
                Analyze this dataset and provide 3-5 key insights:
                {data_description}

                Focus on:
                1. Patterns or trends over months
                2. Correlations between variables
                3. Anomalies or interesting data points
                4. Suggestions for further analysis
                """

                print("Generating AI insights...")
                insights = get_response(insight_prompt)

                print("\n=== AI Analysis Results ===")
                print(insights)

            except Exception as e:
                print(f"Error getting AI insights: {e}")
                print("AI insight generation is not available.")

        elif choice == '6':
            print("\nExiting Dashboard. Goodbye!")
            break

        else:
            print("\nInvalid choice. Please select a number between 1 and 6.")

# Run the dashboard
if __name__ == "__main__":
    data_dashboard()

from hands-on-ai.chat import get_response
import random

def generate_questions(topic, number_of_questions=5):
    """Generate quiz questions about a specific topic"""
    system_prompt = f"""
    Create {number_of_questions} multiple-choice quiz questions about {topic}.
    For each question, provide:
    1. The question
    2. Four possible answers labeled A, B, C, D
    3. The correct answer letter
    Format exactly as follows for each question:
    QUESTION: (the question)
    A. (option A)
    B. (option B)
    C. (option C)
    D. (option D)
    CORRECT: (correct letter)
    """

    response = get_response(f"Generate quiz questions about {topic}", system=system_prompt)
    questions = []

    # Parse the response into a structured format
    sections = response.split("QUESTION: ")
    for section in sections[1:]:  # Skip first empty section
        question_parts = section.strip().split("CORRECT: ")
        options_text = question_parts[0]
        correct_answer = question_parts[1].strip()[0]  # Just take the letter

        # Split the question from options
        question_lines = options_text.split("\n")
        question = question_lines[0].strip()
        options = question_lines[1:5]

        questions.append({
            "question": question,
            "options": options,
            "correct": correct_answer
        })

    return questions

def run_quiz():
    """Run an interactive quiz"""
    print("Welcome to the Quiz Bot!")
    topic = input("What topic would you like to be quizzed on? ")

    print(f"\nGenerating quiz questions about {topic}...")
    questions = generate_questions(topic)

    score = 0

    for i, q in enumerate(questions):
        print(f"\nQuestion {i+1}: {q['question']}")
        for option in q['options']:
            print(option)

        user_answer = input("\nYour answer (A, B, C, or D): ").strip().upper()

        if user_answer == q['correct']:
            print("Correct! ✅")
            score += 1
        else:
            print(f"Incorrect. The correct answer was {q['correct']}. ❌")

    print(f"\nQuiz complete! Your score: {score}/{len(questions)}")
    percentage = (score / len(questions)) * 100

    # Get feedback based on score
    feedback_prompt = f"The user scored {percentage}% on a quiz about {topic}. Give them a short, encouraging message based on their score."
    feedback = get_response(feedback_prompt)
    print(f"\n{feedback}")

# Run the quiz
if __name__ == "__main__":
    run_quiz()

from hands-on-ai.chat import get_response

# Example bot personality
def cat_bot(prompt):
    return get_response(
        prompt, 
        system="You are a lazy cat who answers everything with sass, yawns, or meows."
    )

# Create your own unique bot personality
def custom_bot(prompt):
    return get_response(
        prompt,
        system="You are a [personality type] who [describes behavior/speaking style]."
    )

# Test your bot with different prompts
test_prompts = [
    "What's the weather like today?",
    "Explain quantum physics to me.",
    "What should I do this weekend?",
    "Tell me a joke."
]

# Choose which bot to use
my_bot = cat_bot  # Replace with your custom bot

# Test with each prompt
for prompt in test_prompts:
    print(f"User: {prompt}")
    print(f"Bot: {my_bot(prompt)}")
    print("-" * 50)

# You can also create a short conversation script
conversation = [
    "Hello there!",
    "What's your favorite food?",
    "Tell me something interesting about yourself.",
    "Goodbye!"
]

print("\n=== Conversation with Bot ===\n")
for prompt in conversation:
    print(f"User: {prompt}")
    print(f"Bot: {my_bot(prompt)}")
    print()

from hands-on-ai.chat import get_response

# Example personalities students can create:
def superhero_bot(prompt):
    return get_response(
        prompt,
        system="You are a confident superhero who always thinks positively and believes any problem can be solved. You occasionally reference your superpowers and heroic deeds.",
        personality="superhero"
    )

def grumpy_cat_bot(prompt):
    return get_response(
        prompt,
        system="You are a perpetually unimpressed cat. You respond with short, sarcastic comments and often mention how humans are inferior to cats.",
        personality="grumpy"
    )

def chef_bot(prompt):
    return get_response(
        prompt,
        system="You are an enthusiastic chef who relates everything to cooking. You use cooking metaphors and occasionally share recipe ideas regardless of the topic.",
        personality="chef"
    )

# Test your bot with various prompts
test_prompts = [
    "How's the weather today?",
    "Can you help me with my homework?",
    "What's the meaning of life?",
    "Tell me about yourself."
]

# Choose which bot to use
my_bot = superhero_bot  # Change to your custom bot

# Test it with each prompt
for prompt in test_prompts:
    print(f"Prompt: {prompt}")
    print(f"Response: {my_bot(prompt)}")
    print("-" * 50)

import os
import json
from datetime import datetime, timedelta
from hands-on-ai.chat import get_response

class SmartTodoList:
    """
    A smart to-do list that can categorize tasks, set priorities, 
    track due dates, and provide AI-assisted task management.
    """

    def __init__(self):
        self.tasks = []
        self.categories = ["Work", "School", "Personal", "Shopping", "Health", "Other"]
        self.priorities = ["High", "Medium", "Low"]
        self.data_dir = "todo_data"
        self.data_file = os.path.join(self.data_dir, "tasks.json")

        # Create data directory if it doesn't exist
        os.makedirs(self.data_dir, exist_ok=True)

        # Load existing tasks if available
        self.load_tasks()

    def load_tasks(self):
        """Load tasks from the data file."""
        if os.path.exists(self.data_file):
            try:
                with open(self.data_file, 'r') as f:
                    self.tasks = json.load(f)
                print(f"Loaded {len(self.tasks)} tasks from {self.data_file}")
            except json.JSONDecodeError:
                print("Error reading tasks file. Starting with empty task list.")
                self.tasks = []
        else:
            print("No existing tasks file found. Starting with empty task list.")
            self.tasks = []

    def save_tasks(self):
        """Save tasks to the data file."""
        with open(self.data_file, 'w') as f:
            json.dump(self.tasks, f, indent=2)
        print(f"Saved {len(self.tasks)} tasks to {self.data_file}")

    def add_task(self):
        """Add a new task to the list."""
        print("\n=== Add New Task ===")

        # Get task details
        title = input("Task title: ")

        # Select category
        print("\nCategories:")
        for i, category in enumerate(self.categories, 1):
            print(f"{i}. {category}")

        category_choice = input(f"Select category (1-{len(self.categories)}): ")
        try:
            category_idx = int(category_choice) - 1
            category = self.categories[category_idx]
        except (ValueError, IndexError):
            print("Invalid category selection. Using 'Other'.")
            category = "Other"

        # Select priority
        print("\nPriorities:")
        for i, priority in enumerate(self.priorities, 1):
            print(f"{i}. {priority}")

        priority_choice = input(f"Select priority (1-{len(self.priorities)}): ")
        try:
            priority_idx = int(priority_choice) - 1
            priority = self.priorities[priority_idx]
        except (ValueError, IndexError):
            print("Invalid priority selection. Using 'Medium'.")
            priority = "Medium"

        # Set due date
        due_date = None
        has_due_date = input("\nDoes this task have a due date? (y/n): ").lower() == 'y'

        if has_due_date:
            date_format = "%Y-%m-%d"
            date_input = input("Enter due date (YYYY-MM-DD) or relative (e.g., 'tomorrow', '3 days'): ")

            try:
                # Parse relative dates
                if date_input.lower() == 'today':
                    due_date = datetime.now().strftime(date_format)
                elif date_input.lower() == 'tomorrow':
                    due_date = (datetime.now() + timedelta(days=1)).strftime(date_format)
                elif 'days' in date_input.lower():
                    # Parse "X days" format
                    try:
                        days = int(date_input.split()[0])
                        due_date = (datetime.now() + timedelta(days=days)).strftime(date_format)
                    except (ValueError, IndexError):
                        print("Could not parse relative date. Please enter a specific date.")
                else:
                    # Try to parse as YYYY-MM-DD
                    due_date = datetime.strptime(date_input, date_format).strftime(date_format)
            except ValueError:
                print("Invalid date format. Due date will not be set.")

        # Add notes
        notes = input("\nAdd any notes (optional): ")

        # Create task object
        task = {
            "id": len(self.tasks) + 1,
            "title": title,
            "category": category,
            "priority": priority,
            "due_date": due_date,
            "notes": notes,
            "completed": False,
            "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }

        # Add to task list
        self.tasks.append(task)
        print(f"\nTask '{title}' added successfully!")

        # Save updated tasks
        self.save_tasks()

    def view_tasks(self, show_completed=False):
        """Display tasks based on filters."""
        if not self.tasks:
            print("\nNo tasks found.")
            return

        filtered_tasks = [t for t in self.tasks if t["completed"] == show_completed]

        if not filtered_tasks:
            status = "completed" if show_completed else "pending"
            print(f"\nNo {status} tasks found.")
            return

        # Sort tasks: first by due date (None at the end), then by priority
        def sort_key(task):
            # Priority order: High, Medium, Low
            priority_order = {"High": 0, "Medium": 1, "Low": 2}

            # Sort by due date first (None/null dates come last)
            if task["due_date"]:
                return (0, task["due_date"], priority_order.get(task["priority"], 1))
            else:
                return (1, "9999-99-99", priority_order.get(task["priority"], 1))

        sorted_tasks = sorted(filtered_tasks, key=sort_key)

        # Display tasks
        status = "Completed" if show_completed else "Pending"
        print(f"\n=== {status} Tasks ===")

        for i, task in enumerate(sorted_tasks, 1):
            due_str = f"Due: {task['due_date']}" if task['due_date'] else "No due date"

            # Add warning for tasks due today or overdue
            warning = ""
            if task['due_date']:
                try:
                    due_date = datetime.strptime(task['due_date'], "%Y-%m-%d").date()
                    today = datetime.now().date()

                    if due_date < today and not task['completed']:
                        warning = " [OVERDUE!]"
                    elif due_date == today and not task['completed']:
                        warning = " [DUE TODAY!]"
                except ValueError:
                    pass

            print(f"{i}. [{task['priority']}] {task['title']}{warning} - {due_str} ({task['category']})")

        # Return the sorted tasks for selection
        return sorted_tasks

    def toggle_task_status(self):
        """Mark a task as completed or pending."""
        print("\n=== Toggle Task Status ===")

        # Show pending tasks first
        pending_tasks = self.view_tasks(show_completed=False)

        if pending_tasks:
            # Show completed tasks
            print("\n=== Completed Tasks ===")
            completed_tasks = self.view_tasks(show_completed=True)

            # Ask which list to toggle from
            toggle_from = input("\nToggle task from (p)ending or (c)ompleted list? ").lower()

            if toggle_from == 'p' and pending_tasks:
                task_list = pending_tasks
                current_status = False
            elif toggle_from == 'c' and completed_tasks:
                task_list = completed_tasks
                current_status = True
            else:
                print("Invalid selection or no tasks in that category.")
                return

            # Get task number
            task_num = input(f"Enter task number to toggle (1-{len(task_list)}): ")
            try:
                idx = int(task_num) - 1
                selected_task = task_list[idx]

                # Find this task in the main task list and toggle its status
                for task in self.tasks:
                    if task["id"] == selected_task["id"]:
                        task["completed"] = not current_status
                        status = "completed" if task["completed"] else "pending"
                        print(f"\nTask '{task['title']}' marked as {status}.")
                        break

                # Save updated tasks
                self.save_tasks()

            except (ValueError, IndexError):
                print("Invalid task number.")

    def edit_task(self):
        """Edit an existing task."""
        print("\n=== Edit Task ===")

        # Show all tasks for selection
        print("\nAll Tasks:")
        all_tasks = self.tasks.copy()

        # Sort tasks by completion status, then by other criteria
        def sort_key(task):
            return (task["completed"], task.get("due_date", "9999-99-99"), task["priority"])

        sorted_tasks = sorted(all_tasks, key=sort_key)

        for i, task in enumerate(sorted_tasks, 1):
            status = "✓" if task["completed"] else "☐"
            due_str = f"Due: {task['due_date']}" if task['due_date'] else "No due date"
            print(f"{i}. {status} [{task['priority']}] {task['title']} - {due_str} ({task['category']})")

        # Get task to edit
        task_num = input(f"\nEnter task number to edit (1-{len(sorted_tasks)}): ")
        try:
            idx = int(task_num) - 1
            selected_task = sorted_tasks[idx]

            print(f"\nEditing task: {selected_task['title']}")

            # Get updated values
            title = input(f"Title [{selected_task['title']}]: ") or selected_task['title']

            # Select category
            print("\nCategories:")
            for i, category in enumerate(self.categories, 1):
                print(f"{i}. {category}")

            category_choice = input(f"Select category [current: {selected_task['category']}]: ")
            if category_choice:
                try:
                    category_idx = int(category_choice) - 1
                    category = self.categories[category_idx]
                except (ValueError, IndexError):
                    print("Invalid category selection. Keeping current category.")
                    category = selected_task['category']
            else:
                category = selected_task['category']

            # Select priority
            print("\nPriorities:")
            for i, priority in enumerate(self.priorities, 1):
                print(f"{i}. {priority}")

            priority_choice = input(f"Select priority [current: {selected_task['priority']}]: ")
            if priority_choice:
                try:
                    priority_idx = int(priority_choice) - 1
                    priority = self.priorities[priority_idx]
                except (ValueError, IndexError):
                    print("Invalid priority selection. Keeping current priority.")
                    priority = selected_task['priority']
            else:
                priority = selected_task['priority']

            # Update due date
            current_due = selected_task['due_date'] or "None"
            due_choice = input(f"Update due date? Current: {current_due} (y/n): ").lower()

            if due_choice == 'y':
                date_format = "%Y-%m-%d"
                date_input = input("Enter due date (YYYY-MM-DD) or relative (e.g., 'tomorrow', '3 days'): ")

                try:
                    # Parse relative dates
                    if date_input.lower() == 'today':
                        due_date = datetime.now().strftime(date_format)
                    elif date_input.lower() == 'tomorrow':
                        due_date = (datetime.now() + timedelta(days=1)).strftime(date_format)
                    elif 'days' in date_input.lower():
                        # Parse "X days" format
                        try:
                            days = int(date_input.split()[0])
                            due_date = (datetime.now() + timedelta(days=days)).strftime(date_format)
                        except (ValueError, IndexError):
                            print("Could not parse relative date. Keeping current due date.")
                            due_date = selected_task['due_date']
                    elif date_input.lower() in ('none', 'remove', 'clear'):
                        due_date = None
                    else:
                        # Try to parse as YYYY-MM-DD
                        due_date = datetime.strptime(date_input, date_format).strftime(date_format)
                except ValueError:
                    print("Invalid date format. Keeping current due date.")
                    due_date = selected_task['due_date']
            else:
                due_date = selected_task['due_date']

            # Update notes
            current_notes = selected_task['notes'] or "None"
            notes_choice = input(f"Update notes? Current: {current_notes} (y/n): ").lower()

            if notes_choice == 'y':
                notes = input("Enter new notes: ")
            else:
                notes = selected_task['notes']

            # Find this task in the main task list and update it
            for task in self.tasks:
                if task["id"] == selected_task["id"]:
                    task["title"] = title
                    task["category"] = category
                    task["priority"] = priority
                    task["due_date"] = due_date
                    task["notes"] = notes
                    print(f"\nTask '{title}' updated successfully!")
                    break

            # Save updated tasks
            self.save_tasks()

        except (ValueError, IndexError):
            print("Invalid task number.")

    def delete_task(self):
        """Delete a task from the list."""
        print("\n=== Delete Task ===")

        # Show all tasks for selection
        print("\nAll Tasks:")
        all_tasks = self.tasks.copy()

        # Sort tasks by completion status, then by other criteria
        def sort_key(task):
            return (task["completed"], task.get("due_date", "9999-99-99"), task["priority"])

        sorted_tasks = sorted(all_tasks, key=sort_key)

        for i, task in enumerate(sorted_tasks, 1):
            status = "✓" if task["completed"] else "☐"
            due_str = f"Due: {task['due_date']}" if task['due_date'] else "No due date"
            print(f"{i}. {status} [{task['priority']}] {task['title']} - {due_str} ({task['category']})")

        # Get task to delete
        task_num = input(f"\nEnter task number to delete (1-{len(sorted_tasks)}): ")
        try:
            idx = int(task_num) - 1
            selected_task = sorted_tasks[idx]

            # Confirm deletion
            confirm = input(f"Are you sure you want to delete '{selected_task['title']}'? (y/n): ").lower()

            if confirm == 'y':
                # Remove task from list
                self.tasks = [t for t in self.tasks if t["id"] != selected_task["id"]]
                print(f"\nTask '{selected_task['title']}' deleted successfully!")

                # Save updated tasks
                self.save_tasks()
            else:
                print("Deletion cancelled.")

        except (ValueError, IndexError):
            print("Invalid task number.")

    def get_ai_recommendations(self):
        """Get AI-assisted recommendations for task management."""
        if not self.tasks:
            print("\nNo tasks found. Please add some tasks first.")
            return

        print("\n=== AI Task Management Recommendations ===")
        print("Analyzing your tasks...")

        try:
            # Prepare task data for AI
            today = datetime.now().date()

            # Count tasks by category
            category_counts = {}
            for task in self.tasks:
                cat = task["category"]
                if cat in category_counts:
                    category_counts[cat] += 1
                else:
                    category_counts[cat] = 1

            # Count overdue tasks
            overdue_tasks = []
            for task in self.tasks:
                if task["due_date"] and not task["completed"]:
                    try:
                        due_date = datetime.strptime(task["due_date"], "%Y-%m-%d").date()
                        if due_date < today:
                            overdue_tasks.append({
                                "title": task["title"],
                                "due_date": task["due_date"],
                                "days_overdue": (today - due_date).days,
                                "priority": task["priority"]
                            })
                    except ValueError:
                        pass

            # Get tasks due today
            today_tasks = []
            for task in self.tasks:
                if task["due_date"] and not task["completed"]:
                    try:
                        due_date = datetime.strptime(task["due_date"], "%Y-%m-%d").date()
                        if due_date == today:
                            today_tasks.append({
                                "title": task["title"],
                                "priority": task["priority"],
                                "category": task["category"]
                            })
                    except ValueError:
                        pass

            # Get high priority tasks
            high_priority = []
            for task in self.tasks:
                if task["priority"] == "High" and not task["completed"]:
                    high_priority.append({
                        "title": task["title"],
                        "due_date": task["due_date"],
                        "category": task["category"]
                    })

            # Create prompt for AI
            prompt = f"""
            Based on the following task data, please provide helpful task management recommendations:

            Task summary:
            - Total tasks: {len(self.tasks)}
            - Completed tasks: {sum(1 for t in self.tasks if t["completed"])}
            - Pending tasks: {sum(1 for t in self.tasks if not t["completed"])}

            Category breakdown: {category_counts}

            Overdue tasks ({len(overdue_tasks)}):
            {overdue_tasks if overdue_tasks else "None"}

            Tasks due today ({len(today_tasks)}):
            {today_tasks if today_tasks else "None"}

            High priority pending tasks ({len(high_priority)}):
            {high_priority if high_priority else "None"}

            Please provide:
            1. A prioritized action plan for the next 24 hours
            2. Task management tips based on the current workload
            3. Suggestions for which tasks to focus on first

            Keep your response friendly, practical and under 300 words.
            """

            # Get AI recommendations
            recommendations = get_response(prompt)
            print("\n" + recommendations)

        except Exception as e:
            print(f"Error getting AI recommendations: {e}")
            print("Unable to generate AI recommendations at this time.")

    def run(self):
        """Run the main to-do list interface."""
        print("=== Smart To-Do List ===")

        while True:
            print("\nOptions:")
            print("1. Add new task")
            print("2. View pending tasks")
            print("3. View completed tasks")
            print("4. Toggle task status")
            print("5. Edit task")
            print("6. Delete task")
            print("7. Get AI recommendations")
            print("8. Exit")

            choice = input("\nSelect an option (1-8): ")

            if choice == '1':
                self.add_task()
            elif choice == '2':
                self.view_tasks(show_completed=False)
            elif choice == '3':
                self.view_tasks(show_completed=True)
            elif choice == '4':
                self.toggle_task_status()
            elif choice == '5':
                self.edit_task()
            elif choice == '6':
                self.delete_task()
            elif choice == '7':
                self.get_ai_recommendations()
            elif choice == '8':
                print("\nExiting Smart To-Do List. Goodbye!")
                break
            else:
                print("Invalid choice. Please select a number between 1 and 8.")

# Run the to-do list
if __name__ == "__main__":
    todo_list = SmartTodoList()
    todo_list.run()