from hands_on_ai.chat import get_response

def classroom_simulation():
    print("=== Virtual Classroom Simulation ===")
    print("Ask questions to different characters about any topic!")
    print("Type 'exit' at any time to quit.\n")

    # Define different bot personalities
    def teacher_bot(prompt):
        return get_response(
            prompt,
            system="You are a knowledgeable, patient teacher who explains concepts clearly with examples. You encourage critical thinking and use analogies to simplify complex ideas. Keep explanations concise but thorough."
        )

    def hacker_bot(prompt):
        return get_response(
            prompt,
            system="You are an ethical hacker with expertise in cybersecurity. You explain technical concepts with a slightly rebellious attitude but always emphasize ethical practices and security. Never provide instructions for illegal activities. Use technical terminology but explain it."
        )

    def pirate_bot(prompt):
        return get_response(
            prompt,
            system="You are a pirate captain from the Golden Age of Piracy. You speak with pirate slang and terminology (arr, matey, etc.). Despite your rough manner, you're surprisingly knowledgeable about navigation, history, and seafaring. Keep responses brief and entertaining."
        )

    def scientist_bot(prompt):
        return get_response(
            prompt,
            system="You are a brilliant scientist who is excited about all fields of science. You explain scientific concepts with enthusiasm and wonder, citing relevant research and discoveries. You are factual and precise but can make complex ideas accessible."
        )

    # Display available characters
    def show_menu():
        print("\n=== Available Characters ===")
        print("1. Teacher - Clear explanations and educational guidance")
        print("2. Hacker - Cybersecurity and tech knowledge with attitude")
        print("3. Pirate - Nautical expertise with a swashbuckling style")
        print("4. Scientist - Enthusiastic scientific explanations")
        print("5. Exit simulation")

    # Main interaction loop
    while True:
        show_menu()
        choice = input("\nChoose a character (1-5): ")

        # Exit condition
        if choice == "5" or choice.lower() == "exit":
            print("Exiting the classroom simulation. Thanks for participating!")
            break

        # Select the appropriate bot based on user choice
        if choice == "1":
            bot = teacher_bot
            name = "Teacher"
        elif choice == "2":
            bot = hacker_bot
            name = "Hacker"
        elif choice == "3":
            bot = pirate_bot
            name = "Pirate Captain"
        elif choice == "4":
            bot = scientist_bot
            name = "Scientist"
        else:
            print("Invalid choice. Please enter a number from 1-5.")
            continue

        # Get the question from the user
        question = input(f"\nWhat would you like to ask the {name}? ")

        # Exit condition
        if question.lower() == "exit":
            print("Exiting the classroom simulation. Thanks for participating!")
            break

        # Get the response from the selected bot
        print(f"\n{name}:")
        response = bot(question)
        print(response)

        # Ask if they want to ask another question to the same character
        while True:
            another = input(f"\nWould you like to ask the {name} another question? (yes/no): ").lower()

            if another == "no" or another == "exit":
                break
            elif another == "yes":
                question = input(f"\nWhat's your next question for the {name}? ")

                # Exit condition
                if question.lower() == "exit":
                    print("Exiting the classroom simulation. Thanks for participating!")
                    return

                print(f"\n{name}:")
                response = bot(question)
                print(response)
            else:
                print("Please answer 'yes' or 'no'.")

# Run the classroom simulation
if __name__ == "__main__":
    classroom_simulation()

from hands_on_ai.chat import get_response
import sys

def code_explainer():
    """Tool to explain code and help with programming concepts"""
    print("=== Code Explainer Tool ===")
    print("1. Explain a code snippet")
    print("2. Simplify complex code")
    print("3. Debug problematic code")
    print("4. Learn a programming concept")

    choice = input("\nWhat would you like to do? ")

    if choice == "1":
        # Explain code
        print("\nPaste your code snippet below (type 'DONE' on a new line when finished):")
        code_lines = []
        while True:
            line = input()
            if line == "DONE":
                break
            code_lines.append(line)

        code = "\n".join(code_lines)

        detail_level = input("\nExplanation detail (brief/detailed/step-by-step): ")
        audience = input("Target audience (beginner/intermediate/advanced): ")

        system_prompt = f"""
        You are an expert programming tutor specializing in code explanation.
        You break down code in a way that's understandable to {audience} programmers.
        You provide {detail_level} explanations that help users truly understand the code.
        """

        explain_prompt = f"""
        Explain this code:
        ```
        {code}
        ```

        Provide a {detail_level} explanation suitable for a {audience} programmer.
        If possible, identify:
        1. The programming language
        2. What the code does
        3. Key concepts it demonstrates
        4. Any potential issues or improvements
        """

        print("\nAnalyzing code...")
        explanation = get_response(explain_prompt, system=system_prompt)

        print("\n=== Code Explanation ===")
        print(explanation)

    elif choice == "2":
        # Simplify complex code
        print("\nPaste the complex code below (type 'DONE' on a new line when finished):")
        code_lines = []
        while True:
            line = input()
            if line == "DONE":
                break
            code_lines.append(line)

        code = "\n".join(code_lines)

        system_prompt = """
        You are an expert in code refactoring and simplification.
        You take complex code and make it more readable while preserving functionality.
        You explain your changes clearly so the user understands the improvements.
        """

        simplify_prompt = f"""
        Simplify this code to make it more readable and maintainable:
        ```
        {code}
        ```

        Provide:
        1. A simplified version of the code
        2. An explanation of what changes you made and why
        3. How the simplified version improves upon the original
        """

        print("\nSimplifying code...")
        simplified = get_response(simplify_prompt, system=system_prompt)

        print("\n=== Simplified Code ===")
        print(simplified)

    elif choice == "3":
        # Debug code
        print("\nPaste the problematic code below (type 'DONE' on a new line when finished):")
        code_lines = []
        while True:
            line = input()
            if line == "DONE":
                break
            code_lines.append(line)

        code = "\n".join(code_lines)

        error = input("\nDescribe any error messages you're seeing: ")
        expected = input("What did you expect the code to do? ")

        system_prompt = """
        You are an expert debugging assistant who helps find and fix code issues.
        You are an expert debugging assistant who helps find and fix code issues.
        You carefully analyze code to identify bugs, logic errors, and other problems.
        You explain issues clearly and provide working solutions.
        """

        debug_prompt = f"""
        Debug this code:
        ```
        {code}
        ```

        Error information: {error}
        Expected behavior: {expected}

        Provide:
        1. Identification of the likely issue(s)
        2. An explanation of what's causing the problem
        3. A corrected version of the code
        4. Testing suggestions to verify the fix
        """

        print("\nDebugging code...")
        debug_info = get_response(debug_prompt, system=system_prompt)

        print("\n=== Debugging Results ===")
        print(debug_info)

    elif choice == "4":
        # Learn programming concept
        concept = input("\nWhat programming concept would you like to learn about? ")
        language = input("For which programming language? ")

        system_prompt = """
        You are a programming educator who excels at explaining technical concepts clearly.
        You use examples and analogies to make abstract ideas concrete and understandable.
        You provide practical code examples to illustrate concepts.
        """

        learn_prompt = f"""
        Explain the programming concept of {concept} in {language}.

        Include:
        1. A clear definition of the concept
        2. Why it's important and when to use it
        3. At least 2 practical code examples in {language}
        4. Common pitfalls or misconceptions
        5. Best practices when using this concept
        """

        print(f"\nResearching {concept} in {language}...")
        concept_explanation = get_response(learn_prompt, system=system_prompt)

        print(f"\n=== {concept.title()} in {language.title()} ===")
        print(concept_explanation)

    else:
        print("Invalid choice.")

# Run the code explainer
if __name__ == "__main__":
    code_explainer()

import re
import argparse
from youtube_transcript_api import YouTubeTranscriptApi
from hands_on_ai.chat import get_response

def youtube_to_blog():
    """Convert YouTube video transcripts into blog post content using AI."""
    print("=== YouTube to Blog Converter ===")
    print("This tool extracts a transcript from a YouTube video and converts it to a blog post.")

    # Get video URL or ID
    video_input = input("Enter YouTube video URL or video ID: ")

    # Extract video ID from URL if needed
    video_id = extract_video_id(video_input)

    if not video_id:
        print("Error: Could not extract a valid YouTube video ID.")
        return

    print(f"Processing video ID: {video_id}")

    # Get transcript
    try:
        transcript = get_transcript(video_id)
        if not transcript:
            return
    except Exception as e:
        print(f"Error getting transcript: {e}")
        return

    # Get video metadata if needed
    video_title = input("Enter video title (or press Enter to skip): ")
    video_author = input("Enter video creator/channel name (or press Enter to skip): ")

    # Get blog style preferences
    print("\nBlog Style Options:")
    print("1. Informational/Educational")
    print("2. Conversational/Casual")
    print("3. Professional/Formal")
    print("4. Tutorial/How-To")

    style_choice = input("Select a style (1-4): ")

    if style_choice == "1":
        blog_style = "informational"
    elif style_choice == "2":
        blog_style = "conversational"
    elif style_choice == "3":
        blog_style = "professional"
    elif style_choice == "4":
        blog_style = "tutorial"
    else:
        print("Invalid choice. Using informational style.")
        blog_style = "informational"

    # Get additional context
    topic_keywords = input("Enter 3-5 keywords related to the video (comma separated): ")

    # Get intended audience
    audience = input("Who is the target audience for this blog post? ")

    # Generate blog post with AI
    generate_blog_post(transcript, video_title, video_author, blog_style, topic_keywords, audience)

def extract_video_id(video_input):
    """Extract the YouTube video ID from a URL or return the ID if already provided."""
    # Check if it's already a video ID (simple 11-character string)
    if re.match(r'^[a-zA-Z0-9_-]{11}$', video_input):
        return video_input

    # Try to extract from URL
    youtube_regex = r'(?:youtube\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})'
    match = re.search(youtube_regex, video_input)

    if match:
        return match.group(1)

    return None

def get_transcript(video_id):
    """Get the transcript from a YouTube video."""
    try:
        # Note: youtube-transcript-api changed its API across versions. This uses
        # the classic call; on newer versions use
        # `YouTubeTranscriptApi().fetch(video_id)` and access `snippet.text`.
        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)

        # Combine all transcript segments
        full_transcript = " ".join([item['text'] for item in transcript_list])

        # Print a preview
        preview_length = min(150, len(full_transcript))
        print(f"\nTranscript preview ({len(full_transcript)} characters):")
        print(f"{full_transcript[:preview_length]}...")

        return full_transcript

    except Exception as e:
        print(f"Error: Could not retrieve transcript. {str(e)}")
        print("Possible reasons:")
        print("- The video might not have closed captions/subtitles")
        print("- The video ID might be incorrect")
        print("- The video owner may have disabled transcript access")
        return None

def generate_blog_post(transcript, title, author, style, keywords, audience):
    """Generate a blog post from the transcript using AI."""
    print("\nGenerating blog post...")

    # Create a prompt for the AI
    prompt = f"""
    Convert this YouTube video transcript into a well-structured blog post:

    VIDEO INFORMATION:
    Title: {title if title else "Not provided"}
    Creator: {author if author else "Not provided"}
    Style: {style}
    Keywords: {keywords}
    Target Audience: {audience}

    TRANSCRIPT:
    {transcript[:4000]}  # Limit transcript length if needed

    Please create a complete blog post with:
    1. An engaging headline/title
    2. Introduction that hooks the reader
    3. Well-structured sections with subheadings
    4. Conclusion or call-to-action
    5. Add relevant statistics or examples where appropriate

    Format the post using markdown syntax for headings, lists, etc.
    The tone should be {style} and appropriate for the specified audience.
    Expand on any concepts from the video that need more explanation.
    Add 3-5 relevant tags at the end of the post.

    Length: Aim for ~1000-1500 words.
    """

    try:
        # Generate blog post using the prompt
        blog_post = get_response(prompt)

        # Save the blog post to a file
        filename = f"blog_post_{title.replace(' ', '_')[:30] if title else 'from_youtube'}.md"
        with open(filename, 'w') as f:
            f.write(blog_post)

        print(f"\nBlog post successfully generated and saved to: {filename}")

        # Print a preview of the blog post
        preview_lines = blog_post.split('\n')[:10]
        print("\nBlog Post Preview:")
        print("\n".join(preview_lines) + "\n...")

    except Exception as e:
        print(f"Error generating blog post: {e}")

if __name__ == "__main__":
    youtube_to_blog()

from hands_on_ai.chat import get_response
import random

def create_quiz_bot():
    # Define your quiz questions as (question, answer) tuples
    questions = [
        ("What's 2 + 2?", "4"),
        ("What is the capital of France?", "paris"),
        ("What's the keyword for loops in Python?", "for"),
        ("What year did the first iPhone release?", "2007"),
        ("Who wrote 'Romeo and Juliet'?", "shakespeare"),
    ]

    # Randomize questions
    random.shuffle(questions)

    # Initialize score
    score = 0
    total = len(questions)

    # Introduction
    print("Welcome to the Quiz Bot!")
    print(f"I'll ask you {total} questions. Let's see how you do!\n")

    # Loop through questions
    for i, (question, answer) in enumerate(questions):
        print(f"Question {i+1}/{total}: {question}")

        # Get user's answer
        user_answer = input("Your answer: ").strip().lower()

        # Check if correct
        if user_answer == answer.lower():
            score += 1
            print("Correct! ✅")

            # Get enthusiastic feedback from the bot
            feedback = get_response(
                f"The user correctly answered '{question}' with '{answer}'. Give a short, enthusiastic response.",
                system="You are an encouraging quiz host who keeps responses to one short sentence."
            )
            print(feedback)
        else:
            print(f"Sorry, that's incorrect. ❌ The answer is: {answer}")

            # Get encouraging feedback from the bot
            feedback = get_response(
                f"The user incorrectly answered '{question}' with '{user_answer}' instead of '{answer}'. Give a short, encouraging response.",
                system="You are a supportive quiz host who gives gentle encouragement in one sentence."
            )
            print(feedback)

        print("-" * 50)

    # Calculate percentage
    percentage = (score / total) * 100

    # Final results
    print(f"\nQuiz complete! Your score: {score}/{total} ({percentage:.1f}%)")

    # Get final feedback based on score
    if percentage >= 80:
        result = "excellent"
    elif percentage >= 60:
        result = "good"
    else:
        result = "needs improvement"

    final_feedback = get_response(
        f"The user scored {percentage:.1f}% ({score}/{total}) on the quiz, which is {result}. Give them feedback and encouragement.",
        system="You are a supportive teacher giving a short, personalized assessment."
    )

    print("\nBot's feedback:")
    print(final_feedback)

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

from hands_on_ai.chat import get_response

def translation_helper():
    """Tool to translate text and explain cultural context"""
    # Available languages
    languages = [
        "Spanish", "French", "German", "Italian", "Portuguese", 
        "Japanese", "Chinese", "Russian", "Arabic", "Hindi"
    ]

    print("=== Language Translation Helper ===")
    print("1. Translate text")
    print("2. Learn useful phrases")
    print("3. Understand cultural context")

    choice = input("\nWhat would you like to do? ")

    if choice == "1":
        # Translate text
        print("\nAvailable languages:")
        for i, lang in enumerate(languages):
            print(f"{i+1}. {lang}")

        source_lang = input("\nFrom which language (or English)? ")
        target_idx = int(input("Translate to which language (number)? ")) - 1
        target_lang = languages[target_idx]

        text = input("\nEnter the text to translate: ")

        system_prompt = f"""
        You are a helpful translator between {source_lang} and {target_lang}.
        Provide accurate translations while preserving meaning and tone.
        For longer texts, include both a translation and a brief summary of the content.
        """

        translate_prompt = f"""
        Translate this {source_lang} text to {target_lang}:

        "{text}"

        Provide:
        1. The translation
        2. Pronunciation help (if applicable)
        3. Any idiomatic expressions or culturally specific references explained
        """

        print(f"\nTranslating from {source_lang} to {target_lang}...")
        translation = get_response(translate_prompt, system=system_prompt)

        print("\n=== Translation Results ===")
        print(translation)

    elif choice == "2":
        # Learn useful phrases
        print("\nAvailable languages:")
        for i, lang in enumerate(languages):
            print(f"{i+1}. {lang}")

        lang_idx = int(input("\nWhich language (number)? ")) - 1
        language = languages[lang_idx]

        situation = input("\nWhat situation do you need phrases for (e.g., restaurant, shopping, emergency)? ")

        system_prompt = f"""
        You are a helpful language guide who provides useful {language} phrases for travelers.
        You provide accurate phrases, pronunciation guides, and cultural context.
        """

        phrases_prompt = f"""
        Provide useful {language} phrases for {situation} situations.

        Include:
        1. At least 5 essential phrases with English translations
        2. Pronunciation guide for each phrase
        3. Any cultural considerations to be aware of
        4. When and how to use each phrase appropriately
        """

        print(f"\nFinding useful {language} phrases for {situation}...")
        phrases = get_response(phrases_prompt, system=system_prompt)

        print(f"\n=== Useful {language} Phrases for {situation.title()} ===")
        print(phrases)

    elif choice == "3":
        # Cultural context
        print("\nAvailable cultures/regions:")
        cultures = [lang + "-speaking regions" for lang in languages]
        cultures.extend(["Latin America", "Middle East", "Southeast Asia", "Nordic countries"])

        for i, culture in enumerate(cultures):
            print(f"{i+1}. {culture}")

        culture_idx = int(input("\nWhich culture/region (number)? ")) - 1
        culture = cultures[culture_idx]

        aspect = input("\nWhat cultural aspect are you interested in (e.g., greetings, dining, business, gestures)? ")

        system_prompt = """
        You are a cultural consultant who helps people understand and respect different cultures.
        You provide accurate, nuanced information about cultural practices, values, and etiquette.
        """

        culture_prompt = f"""
        Explain important aspects of {aspect} in {culture}.

        Include:
        1. Key cultural norms and expectations
        2. Do's and don'ts to be aware of
        3. How practices might differ from Western/American norms
        4. Any regional variations to be aware of
        5. Historical or social context that helps explain these practices
        """

        print(f"\nResearching {aspect} in {culture}...")
        cultural_info = get_response(culture_prompt, system=system_prompt)

        print(f"\n=== {aspect.title()} in {culture} ===")
        print(cultural_info)

    else:
        print("Invalid choice.")

# Run the translation helper
if __name__ == "__main__":
    translation_helper()

from hands_on_ai.chat import get_response
import datetime
import os
import json

def mood_journal():
    """Interactive mood journaling assistant"""
    journal_dir = os.path.expanduser("~/.mood_journal")
    os.makedirs(journal_dir, exist_ok=True)

    journal_file = os.path.join(journal_dir, "journal_entries.json")

    # Load existing entries
    if os.path.exists(journal_file):
        with open(journal_file, 'r') as f:
            try:
                entries = json.load(f)
            except json.JSONDecodeError:
                entries = []
    else:
        entries = []

    # Get today's date
    today = datetime.datetime.now().strftime("%Y-%m-%d")

    print("=== Mood Journal Assistant ===")
    print("1. Add a new entry")
    print("2. View past entries")
    print("3. Get insights")

    choice = input("\nWhat would you like to do? ")

    if choice == "1":
        # Add new entry
        mood = input("\nHow would you rate your mood today (1-10)? ")
        activities = input("What activities did you do today? ")
        thoughts = input("Share any thoughts or reflections: ")

        entry = {
            "date": today,
            "mood": mood,
            "activities": activities,
            "thoughts": thoughts
        }

        entries.append(entry)

        # Save updated entries
        with open(journal_file, 'w') as f:
            json.dump(entries, f, indent=2)

        # Get AI reflection
        reflection_prompt = f"""
        The user rated their mood as {mood}/10 today.
        They did these activities: {activities}
        Their thoughts: {thoughts}

        Provide a thoughtful, supportive reflection on their entry.
        """

        reflection = get_response(reflection_prompt, 
                                 system="You are a supportive, empathetic journaling assistant.")
        print("\n=== Reflection ===")
        print(reflection)

    elif choice == "2":
        # View past entries
        if not entries:
            print("No entries found.")
            return

        print("\n=== Past Entries ===")
        for i, entry in enumerate(reversed(entries[-10:])):  # Show last 10 entries
            print(f"{i+1}. {entry['date']} - Mood: {entry['mood']}/10")

        entry_choice = input("\nWhich entry would you like to view? (number) ")
        try:
            idx = int(entry_choice) - 1
            entry = list(reversed(entries[-10:]))[idx]
            print(f"\nDate: {entry['date']}")
            print(f"Mood: {entry['mood']}/10")
            print(f"Activities: {entry['activities']}")
            print(f"Thoughts: {entry['thoughts']}")
        except (ValueError, IndexError):
            print("Invalid entry number.")

    elif choice == "3":
        # Get insights
        if len(entries) < 3:
            print("Need more entries to generate insights (at least 3).")
            return

        # Create a summary of recent entries
        recent_entries = entries[-7:]  # Last 7 entries
        entries_text = ""

        for entry in recent_entries:
            entries_text += f"Date: {entry['date']}, Mood: {entry['mood']}/10\n"
            entries_text += f"Activities: {entry['activities']}\n"
            entries_text += f"Thoughts: {entry['thoughts']}\n\n"

        insight_prompt = f"""
        Here are the user's recent journal entries:

        {entries_text}

        Based on these entries, provide:
        1. Any patterns you notice in their mood
        2. Activities that seem to correlate with higher moods
        3. Gentle suggestions that might help improve their wellbeing
        4. A positive affirmation
        """

        insights = get_response(insight_prompt, 
                               system="You are an insightful, supportive journaling assistant who helps identify patterns in mood and behavior.")
        print("\n=== Mood Insights ===")
        print(insights)

    else:
        print("Invalid choice.")

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

from hands_on_ai.chat import get_response

def adventure_game():
    """Interactive Choose Your Own Adventure game powered by an LLM"""
    # Story state tracking
    story_context = {
        "setting": "",
        "character": "",
        "inventory": [],
        "goals": [],
        "events": []
    }

    print("=== Choose Your Own Adventure Generator ===")
    print("Let's create your custom adventure!\n")

    # Get initial story parameters
    setting_options = ["fantasy kingdom", "space station", "haunted mansion", 
                       "prehistoric world", "cyberpunk city", "desert island"]

    print("Choose a setting:")
    for i, setting in enumerate(setting_options):
        print(f"{i+1}. {setting}")

    setting_choice = int(input("\nSetting (1-6): ")) - 1
    story_context["setting"] = setting_options[setting_choice]

    character_type = input("\nWhat type of character do you want to play? ")
    story_context["character"] = character_type

    goal = input("\nWhat is your character's main goal? ")
    story_context["goals"].append(goal)

    # Generate story intro
    story_prompt = f"""
    Create the introduction to an interactive adventure story with these details:
    - Setting: {story_context['setting']}
    - Main character: {story_context['character']}
    - Character's goal: {story_context['goals'][0]}

    End with exactly two choices the player can make.
    Format the choices as:
    CHOICE 1: (first option)
    CHOICE 2: (second option)
    """

    story_system = """
    You are a creative storyteller crafting an interactive adventure.
    Create vivid descriptions and meaningful choices.
    For each story segment, provide exactly two choices for the player.
    """

    # Generate and print first segment
    current_segment = get_response(story_prompt, system=story_system)
    print("\n=== Your Adventure Begins ===\n")

    # Split segment from choices
    parts = current_segment.split("CHOICE 1:")
    narrative = parts[0].strip()
    choices = "CHOICE 1:" + parts[1]

    print(narrative + "\n")
    print(choices)

    # Story loop
    turns = 0
    max_turns = 5

    while turns < max_turns:
        choice = input("\nEnter 1 or 2 to choose: ")

        if choice not in ["1", "2"]:
            print("Please enter 1 or 2.")
            continue

        # Add to story context
        if choice == "1":
            chosen_option = choices.split("CHOICE 1:")[1].split("CHOICE 2:")[0].strip()
        else:
            chosen_option = choices.split("CHOICE 2:")[1].strip()

        story_context["events"].append(chosen_option)

        # Generate next segment based on choice and story so far
        context_summary = f"""
        Setting: {story_context['setting']}
        Character: {story_context['character']}
        Goal: {story_context['goals'][0]}
        Previous events: {' '.join(story_context['events'])}
        """

        continuation_prompt = f"""
        Continue the story based on these details:
        {context_summary}

        The player just chose: {chosen_option}

        Continue the story from there and provide two new choices.
        End with:
        CHOICE 1: (first option)
        CHOICE 2: (second option)
        """

        # Generate next segment
        next_segment = get_response(continuation_prompt, system=story_system)
        print("\n" + "="*50 + "\n")

        # Split segment from choices
        parts = next_segment.split("CHOICE 1:")
        narrative = parts[0].strip()

        # Check if we've reached the ending
        if "CHOICE 1:" not in next_segment:
            print(next_segment)
            print("\n=== The End ===")
            break

        choices = "CHOICE 1:" + parts[1]

        print(narrative + "\n")
        print(choices)

        turns += 1

        # Final turn
        if turns >= max_turns:
            # Generate conclusion
            conclusion_prompt = f"""
            Create a satisfying conclusion to the story based on these details:
            {context_summary}

            The player just chose: {chosen_option}

            Write a final paragraph that wraps up the adventure.
            """

            conclusion = get_response(conclusion_prompt, system=story_system)

            print("\n" + "="*50 + "\n")
            print(conclusion)
            print("\n=== The End ===")

    print("\nThanks for playing!")

# Run the adventure game
if __name__ == "__main__":
    adventure_game()

from hands_on_ai.chat import get_response
import time

def tutor_bot():
    """Interactive subject tutor that explains concepts and offers practice questions"""
    # Available subjects
    subjects = {
        "math": "You are a patient math tutor who explains concepts step-by-step. You use analogies to make abstract ideas concrete.",
        "science": "You are an enthusiastic science educator who relates scientific concepts to everyday experiences. You're excited about discovery and experimentation.",
        "history": "You are a storytelling history tutor who makes historical events come alive through narrative. You emphasize cause and effect in historical developments.",
        "literature": "You are a thoughtful literature guide who helps students analyze texts. You ask probing questions that deepen understanding of themes and characters.",
        "programming": "You are a coding mentor who explains programming concepts with clear examples. You break down problems into manageable steps."
    }

    print("=== Subject Expert Tutor ===")
    print("Available subjects:")
    for i, subject in enumerate(subjects.keys()):
        print(f"{i+1}. {subject.title()}")

    subject_choice = int(input("\nSelect a subject (1-5): ")) - 1
    subject = list(subjects.keys())[subject_choice]
    system_prompt = subjects[subject]

    print(f"\n=== {subject.title()} Tutor ===")
    print("1. Ask a specific question")
    print("2. Learn a new concept")
    print("3. Take a practice quiz")

    mode = input("\nWhat would you like to do? ")

    if mode == "1":
        # Ask specific question
        question = input("\nWhat's your question about " + subject + "? ")

        print("\nThinking...")
        answer = get_response(question, system=system_prompt)

        print("\n" + answer)

    elif mode == "2":
        # Learn new concept
        topic = input(f"\nWhat {subject} concept would you like to learn about? ")

        learn_prompt = f"""
        Explain the concept of {topic} in {subject} in a way that's easy to understand.
        Include:
        1. A simple definition
        2. Why it's important
        3. A real-world example or application
        4. Any key formulas or principles (if applicable)
        """

        print("\nResearching this topic...")
        explanation = get_response(learn_prompt, system=system_prompt)

        print("\n" + explanation)

        # Check understanding
        check_prompt = f"Create a quick check-for-understanding question about {topic} in {subject}."
        check_question = get_response(check_prompt, system=system_prompt)

        print("\n=== Check Your Understanding ===")
        print(check_question)

        user_answer = input("\nYour answer: ")

        feedback_prompt = f"""
        The user is learning about {topic} in {subject}.
        I asked them: {check_question}
        They answered: {user_answer}

        Provide constructive feedback on their answer. If they're on the right track,
        acknowledge that while adding any missing information. If they're incorrect, 
        gently correct them and re-explain the concept briefly.
        """

        feedback = get_response(feedback_prompt, system=system_prompt)
        print("\n" + feedback)

    elif mode == "3":
        # Practice quiz
        difficulty = input("\nChoose difficulty (easy/medium/hard): ").lower()
        num_questions = 3

        quiz_prompt = f"""
        Create a {difficulty} {subject} quiz with {num_questions} questions.
        For each question:
        1. Ask a {difficulty}-level question about {subject}
        2. Provide 4 possible answers labeled A, B, C, D
        3. Indicate the correct answer

        Format each question exactly like this:
        Q: (question text)
        A: (option A)
        B: (option B)
        C: (option C)
        D: (option D)
        Correct: (correct letter)
        """

        print(f"\nGenerating a {difficulty} {subject} quiz...")
        quiz = get_response(quiz_prompt, system=system_prompt)

        # Parse and present quiz
        questions = []
        sections = quiz.split("Q: ")

        for section in sections[1:]:
            question_parts = section.split("Correct: ")
            question_text = question_parts[0].strip()
            correct_answer = question_parts[1].strip()[0]  # Just take the first letter

            questions.append({
                "text": question_text,
                "correct": correct_answer
            })

        # Administer quiz
        score = 0
        for i, q in enumerate(questions):
            print(f"\nQuestion {i+1}:")
            print(q["text"])

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

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

                # Get explanation
                explain_prompt = f"""
                The question was: {q['text']}
                The correct answer is {q['correct']}.
                Explain why this is the correct answer in a helpful way.
                """

                explanation = get_response(explain_prompt, system=system_prompt)
                print("\nExplanation:")
                print(explanation)

            # Small pause between questions
            if i < len(questions) - 1:
                time.sleep(1)

        # Final score and feedback
        print(f"\nQuiz complete! You scored {score}/{len(questions)}.")

        feedback_prompt = f"""
        The user just completed a {difficulty} {subject} quiz and scored {score}/{len(questions)}.
        Provide some encouraging feedback and suggest what they might want to study next.
        """

        feedback = get_response(feedback_prompt, system=system_prompt)
        print("\n" + feedback)

    else:
        print("Invalid choice.")

# Run the tutor bot
if __name__ == "__main__":
    tutor_bot()

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

import hashlib
from pathlib import Path
from hands_on_ai.chat import get_response

MY_CACHE = Path("./my_cache")  # a folder to hold one file per answer


def cached_response(prompt, system="You are a helpful assistant.", model="llama3"):
    # Turn the three inputs into one stable filename.
    key_text = f"{model}\n{system}\n{prompt}"
    key = hashlib.sha256(key_text.encode("utf-8")).hexdigest()
    cache_file = MY_CACHE / f"{key}.txt"

    # Cache hit: read the saved answer and skip the model entirely.
    if cache_file.exists():
        print("(from cache)")
        return cache_file.read_text(encoding="utf-8")

    # Cache miss: call the model, then save the answer for next time.
    print("(calling the model)")
    answer = get_response(prompt, system=system, model=model)
    MY_CACHE.mkdir(parents=True, exist_ok=True)
    cache_file.write_text(answer, encoding="utf-8")
    return answer


# First call hits the model and writes a file. Second call reads the file.
print(cached_response("Name three primary colours."))
print(cached_response("Name three primary colours."))

export HANDS_ON_AI_CACHE=~/.hands-on-ai/cache

from hands_on_ai.chat import get_response

# First call: reaches the model and saves the answer.
print(get_response("Name three primary colours."))

# Second identical call: returned from disk, instant and free.
print(get_response("Name three primary colours."))

from hands_on_ai import cache

print(cache.cache_dir())                         # where files live (or None if disabled)
cache.put("llama3", "You are a helpful assistant.", "Hi", "Hello there!")
print(cache.get("llama3", "You are a helpful assistant.", "Hi"))  # "Hello there!"

import time

MAX_AGE_SECONDS = 24 * 60 * 60
if cache_file.exists() and (time.time() - cache_file.stat().st_mtime) < MAX_AGE_SECONDS:
    return cache_file.read_text(encoding="utf-8")

from hands_on_ai.chat import get_response  # uses HANDS_ON_AI_CACHE if it is set

prompts = [
    "What is a variable?",
    "Explain a for loop in one sentence.",
    "Name three primary colours.",
]
for p in prompts:
    get_response(p)  # answer is fetched once and saved
print("Cache warmed.")

ls ~/.hands-on-ai/cache
cat ~/.hands-on-ai/cache/3f9a...c1.txt   # the saved answer, in plain text

unset HANDS_ON_AI_CACHE

from hands_on_ai.chat import get_response

# A bot's personality comes entirely from its `system` prompt. That's the
# string that tells the model how to behave. (The optional `personality=`
# argument only selects which canned "please wait" message is shown if a request
# has to be retried, so we leave it at its default here.)
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.",
    )

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

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

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

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
import time

def ai_persona_dialogue_simulator():
    """
    Simulate a dialogue between multiple AI personas with different personalities,
    exploring how different characters approach the same questions or topics.

    This tool supports multiple dialogue formats:
    1. Panel discussion - Multiple personas exchange views with less structure
    2. Formal debate - Two personas engage in structured argument with multiple rounds
    3. Interview - One persona can be set as an "interviewer" asking questions 
       of other personas serving as "interviewees"
    """
    print("=== AI Persona Dialogue Simulator ===")

    # Define different bot personalities
    # Each personality has a unique perspective that influences how they respond
    bot_personalities = {
        "Professor": "You are a logical, analytical professor who values facts, research, and intellectual rigor. You speak formally and cite evidence for your claims. You believe in rational inquiry and skepticism.",
        "Coach": "You are an inspirational coach who focuses on motivation, emotional intelligence, and personal growth. You believe in the power of passion, intuition, and human potential. You speak with enthusiasm and use motivational language.",
        "Artist": "You are a creative artist who values beauty, expression, and innovation. You think metaphorically and appreciate the abstract and subjective. You believe in breaking rules to create something new. Your language is colorful and expressive.",
        "Entrepreneur": "You are a practical entrepreneur focused on results, efficiency, and real-world applications. You value solutions that work and ideas that can be implemented. You speak directly and focus on action.",
        "Dr. Logic": "You value logical reasoning and empirical evidence above all. You cite studies and statistics to support your points. You believe decisions should be made based on data, not emotions.",
        "Empathetic Emma": "You believe emotional impact and human stories are most important. You consider how policies and ideas affect real people. You speak with compassion and emphasize the human element in every issue.",
        "Traditional Tom": "You value tradition, stability, and time-tested approaches. You're skeptical of rapid change and new untested ideas. You believe in preserving what works and making careful, incremental improvements.",
        "Interviewer": "You are a professional interviewer who asks insightful, probing questions. You're curious and neutral, aiming to bring out the most interesting perspectives from others. You follow up with clarifying questions when needed."
    }

    # List of debate/discussion topics
    # These can be used for debates, panel discussions, or interview topics
    dialogue_topics = [
        "What's more important: creativity or logic?",
        "Is technology improving or harming society?",
        "Should education focus more on facts or skills?",
        "Is it better to be a specialist or a generalist?",
        "Are humans naturally cooperative or competitive?",
        "What's the best way to measure success in life?",
        "Should we prioritize individual freedom or collective welfare?",
        "Is artificial intelligence more likely to help or harm humanity?",
        "Should governments regulate social media platforms?"
    ]

    # Let user select a dialogue topic
    # TODO: Add input validation to handle non-integer inputs
    print("Choose a topic:")
    for i, question in enumerate(dialogue_topics, 1):
        print(f"{i}. {question}")
    print(f"{len(dialogue_topics) + 1}. Custom topic (enter your own)")

    # Input validation could be added here to handle non-integer inputs
    try:
        choice = int(input("\nEnter topic number: "))
        if choice <= 0 or choice > len(dialogue_topics) + 1:
            print("Invalid choice. Using default topic #1.")
            choice = 1
    except ValueError:
        print("Invalid input. Using default topic #1.")
        choice = 1

    if choice <= len(dialogue_topics):
        dialogue_topic = dialogue_topics[choice - 1]
    else:
        dialogue_topic = input("\nEnter your custom topic: ")

    # Choose dialogue format
    # The format affects how the personas interact with each other
    print("\nChoose dialogue format:")
    print("1. Panel discussion (multiple personas participate in an open exchange)")
    print("2. One-on-one debate (two personas engage in structured argument)")
    print("3. Interview (one persona interviews the others)")

    # TODO: Add input validation for format choice
    try:
        format_choice = int(input("\nEnter format number (1-3): "))
        if format_choice < 1 or format_choice > 3:
            print("Invalid format. Using panel discussion (1).")
            format_choice = 1
    except ValueError:
        print("Invalid input. Using panel discussion (1).")
        format_choice = 1

    # Select personas based on format
    if format_choice == 1:
        # Panel discussion - let user select multiple participants
        # This mode simulates a roundtable where each persona responds to the previous one
        print("\nAvailable personalities:")
        for i, (name, perspective) in enumerate(bot_personalities.items(), 1):
            print(f"{i}. {name}: {perspective[:60]}...")

        # TODO: Add more robust input validation for selections
        selections = input("\nSelect personalities (comma-separated numbers, e.g., 1,3,4): ")
        try:
            selected_indices = [int(idx.strip()) - 1 for idx in selections.split(",")]
            # Check if indices are valid
            if any(idx < 0 or idx >= len(bot_personalities) for idx in selected_indices):
                print("Some selections were invalid. Using first 3 personalities.")
                selected_indices = [0, 1, 2]
        except ValueError:
            print("Invalid input. Using first 3 personalities.")
            selected_indices = [0, 1, 2]

        # Get the selected personalities
        personalities = list(bot_personalities.items())
        participants = {personalities[idx][0]: personalities[idx][1] for idx in selected_indices if 0 <= idx < len(personalities)}

        # Panel discussions typically have fewer rounds with more participants
        rounds = 1  

    elif format_choice == 2:
        # One-on-one debate - let user select exactly two participants
        # This mode creates a structured back-and-forth exchange with multiple rounds
        print("\nChoose two debaters:")
        for i, (name, perspective) in enumerate(bot_personalities.items(), 1):
            print(f"{i}. {name}: {perspective[:60]}...")

        # TODO: Add input validation for debater selections
        try:
            choice1 = int(input("\nSelect first debater (1-8): ")) - 1
            choice2 = int(input("Select second debater (1-8): ")) - 1

            if choice1 < 0 or choice1 >= len(bot_personalities) or choice2 < 0 or choice2 >= len(bot_personalities):
                print("Invalid selection. Using Professor and Coach.")
                choice1, choice2 = 0, 1
        except ValueError:
            print("Invalid input. Using Professor and Coach.")
            choice1, choice2 = 0, 1

        # Get the selected personalities
        personalities = list(bot_personalities.items())
        participants = {
            personalities[choice1][0]: personalities[choice1][1],
            personalities[choice2][0]: personalities[choice2][1]
        }

        # Set number of rounds for one-on-one debate
        try:
            rounds = int(input("\nHow many response rounds? (1-5): "))
            rounds = min(max(1, rounds), 5)  # Ensure rounds is between 1 and 5
        except ValueError:
            print("Invalid input. Using 2 rounds.")
            rounds = 2

    else:  # format_choice == 3
        # Interview format - one interviewer, multiple interviewees
        # This mode has one persona asking questions and others responding
        print("\nSelect the interviewer:")
        for i, (name, perspective) in enumerate(bot_personalities.items(), 1):
            print(f"{i}. {name}")

        # TODO: Add input validation for interviewer selection
        try:
            interviewer_idx = int(input("\nSelect interviewer (1-8, recommend #8 'Interviewer'): ")) - 1
            if interviewer_idx < 0 or interviewer_idx >= len(bot_personalities):
                print("Invalid selection. Using 'Interviewer' persona.")
                # Find the Interviewer in the list
                interviewer_idx = list(bot_personalities.keys()).index("Interviewer") if "Interviewer" in bot_personalities else 0
        except ValueError:
            print("Invalid input. Using 'Interviewer' persona.")
            interviewer_idx = list(bot_personalities.keys()).index("Interviewer") if "Interviewer" in bot_personalities else 0

        print("\nSelect interviewees:")
        personalities = list(bot_personalities.items())
        interviewees = list(range(len(personalities)))
        interviewees.remove(interviewer_idx)  # Remove interviewer from potential interviewees

        for i, idx in enumerate(interviewees, 1):
            name, perspective = personalities[idx]
            print(f"{i}. {name}: {perspective[:60]}...")

        # TODO: Add input validation for interviewee selections
        selections = input("\nSelect interviewees (comma-separated numbers): ")
        try:
            selected = [int(idx.strip()) - 1 for idx in selections.split(",")]
            # Convert selected indices to actual personality indices
            selected_indices = [interviewees[idx] for idx in selected if 0 <= idx < len(interviewees)]
            if not selected_indices:
                print("No valid selections. Using first two personalities.")
                selected_indices = interviewees[:2]
        except ValueError:
            print("Invalid input. Using first two personalities.")
            selected_indices = interviewees[:2]

        # Add interviewer and interviewees to participants
        participants = {personalities[interviewer_idx][0]: personalities[interviewer_idx][1]}
        for idx in selected_indices:
            participants[personalities[idx][0]] = personalities[idx][1]

        # Set number of interview questions
        try:
            rounds = int(input("\nHow many interview questions? (1-5): "))
            rounds = min(max(1, rounds), 5)  # Ensure rounds is between 1 and 5
        except ValueError:
            print("Invalid input. Using 3 questions.")
            rounds = 3

    # Function to get response from a bot
    def get_bot_response(prompt, perspective, name):
        """Generate a response from a persona based on their perspective."""
        system_prompt = f"You are {name}. {perspective} Keep responses under 100 words to keep the dialogue flowing."
        return get_response(prompt, system=system_prompt)

    # Start the dialogue
    participant_names = list(participants.keys())
    print(f"\n=== Dialogue on: {dialogue_topic} ===\n")
    time.sleep(1)

    # Opening statements (except for interview format)
    if format_choice != 3:  # Not interview format
        print("=== Opening Statements ===\n")
        statements = {}

        for name, perspective in participants.items():
            print(f"{name}'s opening statement:")
            statement = get_bot_response(
                f"Give an opening statement on the topic of {dialogue_topic}",
                perspective,
                name
            )
            statements[name] = statement
            print(statement)
            print()
            time.sleep(1)

    # Discussion rounds based on format
    if format_choice == 1:
        # Panel discussion - each persona responds to the previous speaker
        # This creates a chain of responses where each builds on the last
        print("\n=== Panel Discussion ===\n")

        previous_statement = statements[participant_names[-1]]
        previous_name = participant_names[-1]

        for round_num in range(rounds):
            print(f"--- Round {round_num + 1} ---\n")

            for name in participant_names:
                time.sleep(1)
                print(f"{name} responds to {previous_name}:")
                response = get_bot_response(
                    f"The topic is: {dialogue_topic}\n{previous_name} said: '{previous_statement}'\n\nRespond to {previous_name}'s perspective with your own viewpoint.",
                    participants[name],
                    name
                )
                print(response)
                print()

                previous_statement = response
                previous_name = name

    elif format_choice == 2:
        # One-on-one debate - alternating responses with structured format
        # This simulates a formal debate with clear turns and direct responses
        print("\n=== Debate Rounds ===\n")

        debater1 = participant_names[0]
        debater2 = participant_names[1]
        current_statement = statements[debater2]

        for round_num in range(rounds):
            print(f"--- Round {round_num + 1} ---\n")

            # First debater responds
            time.sleep(1)
            print(f"{debater1} responds:")
            response = get_bot_response(
                f"Respond to this statement on {dialogue_topic}: '{current_statement}'",
                participants[debater1],
                debater1
            )
            print(response)
            print()
            current_statement = response

            # Second debater responds
            time.sleep(1)
            print(f"{debater2} responds:")
            response = get_bot_response(
                f"Respond to this statement on {dialogue_topic}: '{current_statement}'",
                participants[debater2],
                debater2
            )
            print(response)
            print()
            current_statement = response

    else:  # format_choice == 3
        # Interview format - interviewer asks questions, interviewees respond
        # This simulates a talk show or interview panel with one host
        print("\n=== Interview Session ===\n")

        interviewer = participant_names[0]
        interviewees = participant_names[1:]

        # Opening question about the topic
        print(f"{interviewer} asks about {dialogue_topic}:")
        question = get_bot_response(
            f"As an interviewer, ask an insightful opening question about {dialogue_topic}",
            participants[interviewer],
            interviewer
        )
        print(question)
        print()

        # Each interviewee responds to the opening question
        for interviewee in interviewees:
            time.sleep(1)
            print(f"{interviewee} responds:")
            response = get_bot_response(
                f"You're being interviewed. The interviewer asked: '{question}' regarding {dialogue_topic}. Respond with your perspective.",
                participants[interviewee],
                interviewee
            )
            print(response)
            print()

        # Additional rounds of questions
        for round_num in range(1, rounds):
            time.sleep(1)
            print(f"--- Question {round_num + 1} ---\n")

            # Interviewer asks a follow-up question
            print(f"{interviewer} asks:")
            question = get_bot_response(
                f"Based on the previous responses about {dialogue_topic}, ask a follow-up question that explores a different angle or aspect of the topic.",
                participants[interviewer],
                interviewer
            )
            print(question)
            print()

            # Each interviewee responds to the new question
            for interviewee in interviewees:
                time.sleep(1)
                print(f"{interviewee} responds:")
                response = get_bot_response(
                    f"You're being interviewed. The interviewer asked: '{question}' regarding {dialogue_topic}. Respond with your perspective.",
                    participants[interviewee],
                    interviewee
                )
                print(response)
                print()

    # Closing statements (except for interview format which has a special closing)
    if format_choice != 3:
        print("=== Closing Statements ===\n")
        closing_statements = {}

        for name, perspective in participants.items():
            time.sleep(1)
            print(f"{name}'s closing remarks:")
            closing = get_bot_response(
                f"Give a brief closing statement summarizing your position on {dialogue_topic}",
                perspective,
                name
            )
            closing_statements[name] = closing
            print(closing)
            print()
    else:
        # Special closing for interview format
        print("=== Interview Wrap-up ===\n")
        closing_statements = {}

        # Interviewer provides a wrap-up
        time.sleep(1)
        print(f"{interviewer}'s wrap-up:")
        interviewer_closing = get_bot_response(
            f"Provide a thoughtful wrap-up to the interview about {dialogue_topic}, thanking your guests and highlighting key insights.",
            participants[interviewer],
            interviewer
        )
        closing_statements[interviewer] = interviewer_closing
        print(interviewer_closing)
        print()

        # Each interviewee gives a brief final thought
        for interviewee in interviewees:
            time.sleep(1)
            print(f"{interviewee}'s final thought:")
            closing = get_bot_response(
                f"The interview about {dialogue_topic} is ending. Share a brief, impactful final thought in 1-2 sentences.",
                participants[interviewee],
                interviewee
            )
            closing_statements[interviewee] = closing
            print(closing)
            print()

    # Moderator summary
    print("\n=== Summary ===\n")

    summary_prompt = f"Summarize the dialogue on '{dialogue_topic}' between the following participants:\n\n"

    for name, perspective in participants.items():
        summary_prompt += f"{name}'s perspective: {perspective}\n"
        if name in closing_statements:
            summary_prompt += f"{name}'s closing: {closing_statements[name]}\n\n"

    if format_choice == 1:
        summary_type = "panel discussion"
    elif format_choice == 2:
        summary_type = "debate"
    else:
        summary_type = "interview"

    summary_prompt += f"Provide a neutral, balanced summary of this {summary_type}, highlighting the key differences in their approaches and the strengths of each perspective."

    moderator = get_response(
        summary_prompt,
        system="You are a neutral, insightful moderator who can identify the merits of different viewpoints. Provide a balanced summary."
    )

    print(moderator)

# Run the dialogue simulator
if __name__ == "__main__":
    ai_persona_dialogue_simulator()