A!leys Galerie

use std::io::{self, Write};
use std::thread;
use std::time::{Duration, Instant};
use crossterm::{
    execute, terminal::{self, EnterAlternateScreen, LeaveAlternateScreen},
    cursor::{Hide, Show},
    event::{Event, KeyCode},
    style::{Print, ResetColor},
    ExecutableCommand, QueueableCommand,
};
use ratatui::{
    backend::CrosstermBackend,
    style::{Style, Stylize},
    text::{Span, Spans},
    widgets::{Block, Borders, Paragraph, Tabs},
    layout::{Constraint, Direction, Layout, Rect},
    Frame,
};

/// A text processing stage that can be chained together
trait ProcessingStage {
    fn process(&self, input: String) -> String;
    fn name(&self) -> &str;
}

/// Capitalize each word in the text
struct CapitalizeStage;
impl ProcessingStage for CapitalizeStage {
    fn process(&self, input: String) -> String {
        input.split_whitespace()
            .map(|word| word.to_uppercase())
            .collect::<Vec<_>>()
            .join(" ")
    }
    fn name(&self) -> &str { "CAPITALIZE" }
}

/// Reverse each word in the text
struct ReverseWordsStage;
impl ProcessingStage for ReverseWordsStage {
    fn process(&self, input: String) -> String {
        input.split_whitespace()
            .map(|word| word.chars().rev().collect())
            .collect::<Vec<_>>()
            .join(" ")
    }
    fn name(&self) -> &str { "REVERSE WORDS" }
}

/// Add emoji to each word
struct EmojiStage;
impl ProcessingStage for EmojiStage {
    fn process(&self, input: String) -> String {
        input.split_whitespace()
            .map(|word| format!("{word} 🌟"))
            .collect::<Vec<_>>()
            .join(" ")
    }
    fn name(&self) -> &str { "ADD EMOJI" }
}

/// A pipeline that chains multiple processing stages with animation
struct TextPipeline {
    stages: Vec<Box<dyn ProcessingStage>>,
    current_stage: usize,
    text: String,
    animated: bool,
    animation_speed: Duration,
}

impl TextPipeline {
    fn new() -> Self {
        let mut stages = Vec::new();
        stages.push(Box::new(CapitalizeStage));
        stages.push(Box::new(ReverseWordsStage));
        stages.push(Box::new(EmojiStage));

        TextPipeline {
            stages,
            current_stage: 0,
            text: String::new(),
            animated: true,
            animation_speed: Duration::from_millis(100),
        }
    }

    fn add_stage(&mut self, stage: Box<dyn ProcessingStage>) {
        self.stages.push(stage);
    }

    fn process_next(&mut self) {
        if self.stages.is_empty() {
            return;
        }

        let stage = &self.stages[self.current_stage];
        let result = stage.process(self.text.clone());
        self.text = result;
        self.current_stage = (self.current_stage + 1) % self.stages.len();
    }

    fn render(&self, frame: &mut Frame, area: Rect) {
        // Create tabs for each stage
        let stages: Vec<String> = self.stages.iter()
            .map(|stage| stage.name().to_string())
            .collect();

        // Create the tabs widget
        let tabs = Tabs::new(stages)
            .block(Block::default().title("Text Processing Pipeline").borders(Borders::ALL))
            .style(Style::default().fg(ratatui::style::Color::White))
            .highlight_style(Style::default().fg(ratatui::style::Color::Yellow))
            .select(self.current_stage);

        // Create the input text widget
        let input_text = Paragraph::new(Spans::from(
            self.text.chars().map(|c| Span::from(c.to_string())))
        )
        .block(Block::default().title("Current Text").borders(Borders::ALL))
        .style(Style::default().fg(ratatui::style::Color::Green));

        // Create the processing stages list
        let stages_list = self.stages.iter()
            .enumerate()
            .map(|(i, stage)| {
                let indicator = if i == self.current_stage {
                    "[⚡]"
                } else {
                    "[ ]"
                };
                format!("{indicator} {}", stage.name())
            })
            .collect::<Vec<_>>()
            .join("\n");

        let stages_widget = Paragraph::new(stages_list)
            .block(Block::default().title("Processing Stages").borders(Borders::ALL))
            .style(Style::default().fg(ratatui::style::Color::Blue));

        // Create the animation widget if enabled
        let animation_widget = if self.animated {
            let dots = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
            let dot = dots[(Instant::now().elapsed().as_millis() / 200) as usize % dots.len()];
            Paragraph::new(Span::from(dot))
                .block(Block::default().borders(Borders::ALL))
                .style(Style::default().fg(ratatui::style::Color::Magenta))
        } else {
            Paragraph::new("").block(Block::default().borders(Borders::ALL))
        };

        // Create the layout
        let vertical_chunks = Layout::vertical([
            Constraint::Percentage(20),
            Constraint::Percentage(60),
            Constraint::Percentage(20),
        ]).split(area);

        // Render everything
        frame.render_widget(tabs, vertical_chunks[0]);
        frame.render_widget(input_text, vertical_chunks[1]);
        frame.render_widget(stages_widget, vertical_chunks[2]);
        frame.render_widget(animation_widget, vertical_chunks[1]);
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize terminal
    let mut stdout = io::stdout();
    execute!(stdout, EnterAlternateScreen, Hide)?;

    let backend = CrosstermBackend::new(stdout);
    let mut terminal = terminal::Terminal::new(backend)?;

    // Initialize the pipeline
    let mut pipeline = TextPipeline::new();

    // Main loop
    let mut should_quit = false;
    while !should_quit {
        terminal.draw(|f| pipeline.render(f, f.size()))?;

        // Check for key press
        if crossterm::event::poll(Duration::from_millis(100))? {
            if let Event::Key(key) = crossterm::event::read()? {
                match key.code {
                    KeyCode::Char('q') => should_quit = true,
                    KeyCode::Char('n') => pipeline.process_next(),
                    KeyCode::Char(' ') => pipeline.animated = !pipeline.animated,
                    KeyCode::Char('t') => {
                        let mut input = String::new();
                        io::stdin().read_line(&mut input)?;
                        pipeline.text = input.trim().to_string();
                    }
                    KeyCode::Char('+') => {
                        if pipeline.animation_speed > Duration::from_millis(10) {
                            pipeline.animation_speed /= 2;
                        }
                    }
                    KeyCode::Char('-') => {
                        pipeline.animation_speed *= 2;
                        if pipeline.animation_speed > Duration::from_secs(1) {
                            pipeline.animation_speed = Duration::from_secs(1);
                        }
                    }
                    _ => {}
                }
            }
        }

        // Small delay to prevent high CPU usage
        thread::sleep(Duration::from_millis(50));
    }

    // Cleanup
    execute!(
        terminal.backend(),
        LeaveAlternateScreen,
        Show,
        ResetColor,
    )?;
    Ok(())
}

// crafting-plugin-generator.js
const fs = require('fs');
const path = require('path');

class CraftingPluginGenerator {
    constructor() {
        this.basePlugin = `
//==============================================================================
// Crafting System for RPG Maker MZ - Generated by CraftingPluginGenerator
//==============================================================================

/*:
 * @plugindesc v1.0.0 - A customizable crafting system for RPG Maker MZ.
 * @author Your Name
 */

(() => {
    'use strict';

    //==========================================================================
    // Parameters
    //==========================================================================
    const parameters = PluginManager.parameters('CraftingSystem');
    const crafting = {
        items: JSON.parse(parameters['CraftingItems'] || '[]'),
        recipes: JSON.parse(parameters['CraftingRecipes'] || '[]'),
        successRate: parseFloat(parameters['CraftingSuccessRate'] || '1.0'),
        failureMessage: parameters['CraftingFailureMessage'] || 'Crafting failed!',
        successMessage: parameters['CraftingSuccessMessage'] || 'Crafting succeeded!'
    };

    // Cache for crafting results
    crafting.cache = {};

    //==========================================================================
    // Game_Action
    //==========================================================================
    const _Game_Action_canUseItem = Game_Action.prototype.canUseItem;
    Game_Action.prototype.canUseItem = function(item, target) {
        if (this.isCraftingAction() && !_Game_Action_canUseItem.call(this, item, target)) {
            return false;
        }
        return _Game_Action_canUseItem.call(this, item, target);
    };

    // Check if this is a crafting action (item with ID 1000+)
    Game_Action.prototype.isCraftingAction = function() {
        return this.itemId() >= 1000;
    };

    //==========================================================================
    // Game_Interpreter
    //==========================================================================
    const _Game_Interpreter_pluginCommand = Game_Interpreter.prototype.pluginCommand;
    Game_Interpreter.prototype.pluginCommand = function(command, args) {
        _Game_Interpreter_pluginCommand.call(this, command, args);
        if (command === 'Crafting') {
            this.handleCraftingCommand(args);
        }
    };

    Game_Interpreter.prototype.handleCraftingCommand = function(args) {
        const subCommand = args.shift();
        switch (subCommand) {
            case 'AddItem':
                this.addCraftingItem(args);
                break;
            case 'AddRecipe':
                this.addCraftingRecipe(args);
                break;
            case 'StartCrafting':
                this.startCraftingProcess(args);
                break;
        }
    };

    Game_Interpreter.prototype.addCraftingItem = function(args) {
        const id = parseInt(args[0]);
        const name = args[1];
        const type = args[2];
        crafting.items.push({ id, name, type });
    };

    Game_Interpreter.prototype.addCraftingRecipe = function(args) {
        const outputId = parseInt(args[0]);
        const inputItems = args.slice(1).map((item, i) => {
            const parts = item.split(',');
            return { id: parseInt(parts[0]), quantity: parseInt(parts[1]) };
        });
        crafting.recipes.push({ outputId, inputItems });
    };

    Game_Interpreter.prototype.startCraftingProcess = function(args) {
        const actorId = parseInt(args[0]);
        const outputId = parseInt(args[1]);

        const actor = $gameActors.actor(actorId);
        if (!actor) return;

        const recipe = crafting.recipes.find(r => r.outputId === outputId);
        if (!recipe) return;

        // Check if actor has all required items
        const hasItems = recipe.inputItems.every(item => {
            return $gameParty.hasItem(item.id, item.quantity);
        });

        if (!hasItems) {
            this.addMessage(crafting.failureMessage);
            return;
        }

        // Calculate success chance (higher if actor is high level)
        const levelBonus = Math.min(0.5, (actor.level - 1) * 0.05);
        const successChance = crafting.successRate + levelBonus;

        if (Math.random() <= successChance) {
            // Success - remove inputs, add output
            recipe.inputItems.forEach(item => {
                $gameParty.loseItem(item.id, item.quantity);
            });
            $gameParty.gainItem(outputId, 1);
            this.addMessage(crafting.successMessage);
        } else {
            this.addMessage(crafting.failureMessage);
        }
    };

    //==========================================================================
    // Menu Manager
    //==========================================================================
    const _Window_Crafting_standardWindowWidth = Window_Crafting.standardWindowWidth;
    Window_Crafting.prototype.standardWindowWidth = function() {
        return _Window_Crafting_standardWindowWidth.call(this) + 200;
    };

    // Add crafting menu to the menu screen
    const _Scene_Menu_create = Scene_Menu.prototype.create;
    Scene_Menu.prototype.create = function() {
        _Scene_Menu_create.call(this);
        this._craftingWindow = new Window_Crafting();
        this.addWindow(this._craftingWindow);
    };

    Scene_Menu.prototype.update = function(sceneId) {
        _Scene_Menu_create.call(this);
        this._craftingWindow.update();
    };

    // Crafting Window
    function Window_Crafting() {
        this.initialize.apply(this, arguments);
    }

    Window_Crafting.prototype = Object.create(Window_Selectable.prototype);
    Window_Crafting.prototype.constructor = Window_Crafting;

    Window_Crafting.prototype.initialize = function() {
        const width = this.windowWidth();
        const height = 300;
        Window_Selectable.prototype.initialize.call(this, 0, 0, width, height);
        this.opacity = 0;
        this.setBackgroundImage('crafting-bg', 1);
        this.refresh();
    };

    Window_Crafting.prototype.drawContent = function() {
        const rect = this.contentRect;
        this.drawText('Crafting System', rect.x, rect.y, rect.width, 'center');

        if (crafting.recipes.length === 0) {
            this.drawText('No recipes available', rect.x, rect.y + 32, rect.width, 'center');
            return;
        }

        const lineHeight = this.itemLineHeight();
        const startY = rect.y + 32;

        crafting.recipes.forEach((recipe, i) => {
            const item = $dataItems[recipe.outputId];
            if (!item) return;

            const y = startY + i * lineHeight;
            const text = item.name;
            this.drawItemName(item, 0, y);
            this.changeTextColor(this.textColor(0));
            this.drawText(text, 80, y, rect.width - 80);
        });
    };

    Window_Crafting.prototype.update = function() {
        if (this._crafting) {
            if (Input.isTriggered('ok')) {
                this._crafting = false;
                this.refresh();
            }
        }
    };

    //==========================================================================
    // Override plugin parameters
    //==========================================================================
    PluginManager.registerCommand('CraftingSystem', 'setItems', function(args) {
        crafting.items = JSON.parse(args[0]);
    });

    PluginManager.registerCommand('CraftingSystem', 'setRecipes', function(args) {
        crafting.recipes = JSON.parse(args[0]);
    });

    PluginManager.registerCommand('CraftingSystem', 'setSuccessRate', function(args) {
        crafting.successRate = parseFloat(args[0]);
    });
})();
        `;

        this sampleItems = [
            { id: 1000, name: "Simple Potion", type: "Healing" },
            { id: 1001, name: "Complex Potion", type: "Healing" },
            { id: 1002, name: "Strength Herb", type: "Boost" },
            { id: 1003, name: "Elixir", type: "Ultimate" }
        ];

        this.sampleRecipes = [
            {
                outputId: 1000,
                inputItems: [
                    { id: 2, quantity: 2 },  // Herb
                    { id: 3, quantity: 1 }   // Crystal
                ]
            },
            {
                outputId: 1001,
                inputItems: [
                    { id: 1000, quantity: 2 },
                    { id: 4, quantity: 3 },
                    { id: 5, quantity: 1 }
                ]
            },
            {
                outputId: 1002,
                inputItems: [
                    { id: 1000, quantity: 1 },
                    { id: 6, quantity: 2 }
                ]
            },
            {
                outputId: 1003,
                inputItems: [
                    { id: 1001, quantity: 1 },
                    { id: 1002, quantity: 1 },
                    { id: 7, quantity: 1 }
                ]
            }
        ];
    }

    generatePlugin(outputPath = 'crafting-plugin.js') {
        const pluginWithData = this.basePlugin
            .replace('// CRAFTING_ITEMS_PLACEHOLDER', JSON.stringify(this.sampleItems))
            .replace('// CRAFTING_RECIPES_PLACEHOLDER', JSON.stringify(this.sampleRecipes));

        fs.writeFileSync(outputPath, pluginWithData);
        console.log(`Plugin generated at: ${path.resolve(outputPath)}`);
    }

    generatePluginWithCustomData(items, recipes, successRate = 0.8, failureMessage = "Crafting failed!", successMessage = "Crafting succeeded!") {
        const pluginWithData = this.basePlugin
            .replace('// CRAFTING_ITEMS_PLACEHOLDER', JSON.stringify(items || this.sampleItems))
            .replace('// CRAFTING_RECIPES_PLACEHOLDER', JSON.stringify(recipes || this.sampleRecipes))
            .replace('crafting.successRate: parseFloat(parameters[\'CraftingSuccessRate\'] || \'1.0\'),',
                    `crafting.successRate: parseFloat(parameters['CraftingSuccessRate'] || '${successRate}'),`)
            .replace("crafting.failureMessage: parameters['CraftingFailureMessage'] || 'Crafting failed!',",
                    `crafting.failureMessage: parameters['CraftingFailureMessage'] || '${failureMessage}',`)
            .replace("crafting.successMessage: parameters['CraftingSuccessMessage'] || 'Crafting succeeded!'",
                    `crafting.successMessage: parameters['CraftingSuccessMessage'] || '${successMessage}'`);

        fs.writeFileSync('custom-crafting-plugin.js', pluginWithData);
        console.log('Custom plugin generated at: custom-crafting-plugin.js');
    }
}

// Example usage with random data generator
class RandomCraftingDataGenerator {
    generateRandomItems(count = 5) {
        const types = ['Healing', 'Boost', 'Ultimate', 'Rare Material', 'Common Material'];
        const items = [];

        for (let i = 0; i < count; i++) {
            items.push({
                id: 1000 + i,
                name: `${types[i % types.length]} Item ${i + 1}`,
                type: types[i % types.length]
            });
        }

        return items;
    }

    generateRandomRecipes(count = 3, maxInputs = 4) {
        const recipes = [];
        const allItems = this.generateRandomItems(count * 2); // Generate more items for recipes

        for (let i = 0; i < count; i++) {
            const inputItems = [];
            const inputCount = Math.floor(Math.random() * maxInputs) + 1;

            for (let j = 0; j < inputCount; j++) {
                const item = allItems[Math.floor(Math.random() * allItems.length)];
                inputItems.push({
                    id: item.id,
                    quantity: Math.floor(Math.random() * 3) + 1
                });
            }

            recipes.push({
                outputId: allItems[i].id,
                inputItems: inputItems
            });
        }

        return recipes;
    }
}

// Main execution
if (require.main === module) {
    const generator = new CraftingPluginGenerator();
    const randomGenerator = new RandomCraftingDataGenerator();

    // Generate default plugin
    generator.generatePlugin();

    // Generate custom plugin with random data
    const customItems = randomGenerator.generateRandomItems();
    const customRecipes = randomGenerator.generateRandomRecipes();
    generator.generatePluginWithCustomData(
        customItems,
        customRecipes,
        0.75,
        "The crafting failed this time!",
        "Success! The crafting was completed with finesse."
    );

    console.log('Plugin generation complete!');
}

"""
ChatGPT_ScrapedTrends
=====================
Scrapes daily trending topics from r/ChatGPT, analyzes sentiment,
and visualizes trends with interactive console display.
"""

from typing import List, Dict, Tuple, Optional
import os
import re
import datetime
import time
import random
from collections import defaultdict

import requests
from bs4 import BeautifulSoup
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib import animation
from matplotlib.animation import FuncAnimation

# Constants
REDDIT_SUBREDDIT = "r/ChatGPT"
MAX_POSTS = 20
SENTIMENT_KEYWORDS = {
    "positive": ["brilliant", "awesome", "amazing", "love", "wow", "incredible", "perfect", "genius", "clever", "cool"],
    "negative": ["terrible", "awful", "hate", "horrible", "bad", "stupid", "dumb", "annoying", "broken", "useless"],
    "neutral": ["ok", "alright", "fine", "average", "decent", "okay", "meh"]
}
COLORS = {
    "positive": "#4CAF50",  # Green
    "negative": "#F44336",  # Red
    "neutral": "#2196F3",  # Blue
    "mixed": "#FF9800"      # Orange
}
CONSOLE_EMOJIS = {
    "positive": "😊",
    "negative": "😠",
    "neutral": "😐",
    "mixed": "🤷"
}

class TrendAnalyzer:
    """
    Core analyzer class for processing scraped Reddit data.
    Handles sentiment analysis, aggregation, and visualization.
    """

    def __init__(self):
        self.posts: List[Dict] = []
        self.aggregate_data: Dict[str, Dict] = defaultdict(dict)

    def clean_text(self, text: str) -> str:
        """Remove markdown, links, and excessive whitespace."""
        if not text:
            return ""
        # Remove markdown links
        text = re.sub(r'\[.*?\]\(.*?\)', '', text)
        # Remove extra whitespace
        text = re.sub(r'\s+', ' ', text).strip()
        # Remove special characters except basic punctuation
        text = re.sub(r'[^\w\s.,!?]', '', text)
        return text.lower()

    def analyze_sentiment(self, text: str) -> str:
        """Determine sentiment using keyword matching."""
        text = self.clean_text(text)
        if not text:
            return "neutral"

        positive = sum(word in text for word in SENTIMENT_KEYWORDS["positive"])
        negative = sum(word in text for word in SENTIMENT_KEYWORDS["negative"])
        neutral = sum(word in text for word in SENTIMENT_KEYWORDS["neutral"])

        if positive > negative and positive > neutral:
            return "positive"
        if negative > positive and negative > neutral:
            return "negative"
        if neutral >= positive and neutral >= negative:
            return "neutral"
        return "mixed"

    def scrape_reddit(self, max_posts: int = MAX_POSTS) -> bool:
        """
        Scrape top posts from r/ChatGPT subreddit.
        Returns True if successful, False otherwise.
        """
        url = f"https://www.reddit.com/r/{REDDIT_SUBREDDIT}/new/.json"
        headers = {
            "User-Agent": "ChatGPT_ScrapedTrends/1.0 (by /u/AileyBot)"
        }

        try:
            response = requests.get(url, headers=headers, timeout=10)
            response.raise_for_status()
            data = response.json()

            posts = data.get("data", {}).get("children", [])
            self.posts = []

            for post in posts[:max_posts]:
                post_data = post.get("data", {})
                if not post_data.get("selftext") and not post_data.get("title"):
                    continue  # Skip posts without content

                content = post_data.get("title", "") + " " + post_data.get("selftext", "")
                sentiment = self.analyze_sentiment(content)
                self.posts.append({
                    "id": post_data.get("id", ""),
                    "title": post_data.get("title", ""),
                    "score": post_data.get("score", 0),
                    "upvote_ratio": post_data.get("upvote_ratio", 0),
                    "created_utc": post_data.get("created_utc", 0),
                    "url": post_data.get("url", ""),
                    "content": content,
                    "sentiment": sentiment,
                    "emoji": CONSOLE_EMOJIS[sentiment]
                })

            return True

        except Exception as e:
            print(f"⚠️  Scraping failed: {str(e)}")
            return False

    def aggregate_data(self) -> None:
        """Aggregate posts by sentiment and other metrics."""
        if not self.posts:
            print("⚠️  No data to aggregate. Run scrape_reddit() first.")
            return

        # Clear previous data
        self.aggregate_data = defaultdict(dict)

        for post in self.posts:
            sentiment = post["sentiment"]
            for metric, value in post.items():
                if metric == "emoji" or metric == "content":
                    continue  # Skip non-numeric metrics
                if metric not in self.aggregate_data[sentiment]:
                    self.aggregate_data[sentiment][metric] = []
                self.aggregate_data[sentiment][metric].append(value)

    def get_summary_stats(self) -> Dict:
        """Calculate summary statistics for visualization."""
        if not self.posts:
            return {}

        total = len(self.posts)
        stats = {
            "total_posts": total,
            "positive": 0,
            "negative": 0,
            "neutral": 0,
            "mixed": 0,
            "avg_score": 0,
            "avg_upvote_ratio": 0,
            "top_post": None,
            "recent_posts": []
        }

        positive = negative = neutral = mixed = 0
        total_score = total_upvote_ratio = 0

        for post in sorted(self.posts, key=lambda x: x["score"], reverse=True):
            if post["sentiment"] == "positive":
                positive += 1
            elif post["sentiment"] == "negative":
                negative += 1
            elif post["sentiment"] == "neutral":
                neutral += 1
            else:
                mixed += 1

            total_score += post["score"]
            total_upvote_ratio += post["upvote_ratio"]

        stats["positive"] = positive
        stats["negative"] = negative
        stats["neutral"] = neutral
        stats["mixed"] = mixed
        stats["avg_score"] = round(total_score / total, 1) if total else 0
        stats["avg_upvote_ratio"] = round((total_upvote_ratio / total) * 100, 1) if total else 0

        if self.posts:
            stats["top_post"] = self.posts[0]
            stats["recent_posts"] = self.posts[:3]  # Most recent 3 posts

        return stats

    def visualize_trends(self, save_path: Optional[str] = None) -> None:
        """Generate an animated bar chart of sentiment trends."""
        if not self.posts:
            print("⚠️  No data to visualize. Run scrape_reddit() first.")
            return

        self.aggregate_data()
        stats = self.get_summary_stats()

        # Prepare data for plotting
        sentiments = ["positive", "negative", "neutral", "mixed"]
        counts = [stats.get(sentiment, 0) for sentiment in sentiments]
        colors = [COLORS[s] for s in sentiments]

        fig, ax = plt.subplots(figsize=(10, 5))
        bars = ax.bar(sentiments, counts, color=colors)
        ax.set_title(f"📈 ChatGPT Trends ({datetime.datetime.now().strftime('%Y-%m-%d')})", fontsize=14)
        ax.set_ylabel("Number of Posts")
        ax.set_xlabel("Sentiment")

        # Add value labels on bars
        for bar in bars:
            height = bar.get_height()
            ax.text(bar.get_x() + bar.get_width()/2., height,
                    f'{int(height)}',
                    ha='center', va='bottom')

        # Add percentage labels
        total = sum(counts)
        for i, (sentiment, count) in enumerate(zip(sentiments, counts)):
            if total > 0:
                percentage = (count / total) * 100
                ax.text(i, count + 0.5, f"{percentage:.1f}%",
                        ha='center', va='bottom', fontsize=9, color='black')

        # Add emoji to each bar
        for i, sentiment in enumerate(sentiments):
            ax.text(i, counts[i] + 0.5, CONSOLE_EMOJIS[sentiment],
                    ha='center', va='bottom', fontsize=16)

        plt.tight_layout()

        if save_path:
            os.makedirs(os.path.dirname(save_path), exist_ok=True)
            plt.savefig(save_path, bbox_inches='tight')
            print(f"✅  Chart saved to {save_path}")

        plt.show()

    def display_interactive_console(self) -> None:
        """Display an interactive console view of the trends."""
        if not self.posts:
            print("⚠️  No data to display. Run scrape_reddit() first.")
            return

        stats = self.get_summary_stats()
        print("\n" + "="*60)
        print(f"📊 ChatGPT Trends Dashboard - {datetime.datetime.now().strftime('%Y-%m-%d')}")
        print("="*60)

        # Summary statistics
        print(f"📌 Total Posts: {stats['total_posts']}")
        print(f"📈 Average Score: {stats['avg_score']} points")
        print(f"👍 Avg. Upvote Ratio: {stats['avg_upvote_ratio']}%")

        print("\n📊 Sentiment Breakdown:")
        for sentiment in ["positive", "negative", "neutral", "mixed"]:
            count = stats.get(sentiment, 0)
            percentage = (count / stats['total_posts']) * 100 if stats['total_posts'] > 0 else 0
            print(f"  {CONSOLE_EMOJIS[sentiment]} {sentiment.capitalize()}: {count} posts ({percentage:.1f}%)")

        # Top post
        if stats["top_post"]:
            top_post = stats["top_post"]
            print(f"\n🔝 Top Post: {top_post['title']}")
            print(f"   Score: {top_post['score']} | Upvote Ratio: {top_post['upvote_ratio']:.1%}")
            print(f"   Sentiment: {top_post['emoji']} {top_post['sentiment']}")
            print(f"   https://reddit.com{top_post['url'].split('reddit.com')[-1]}\n")

        # Recent posts
        if stats["recent_posts"]:
            print("📅 Recent Posts:")
            for i, post in enumerate(stats["recent_posts"], 1):
                print(f"  {i}. {post['emoji']} {post['title']}")
                print(f"     Posted {datetime.datetime.fromtimestamp(post['created_utc'])} ago")
                print(f"     Score: {post['score']} | Upvote Ratio: {post['upvote_ratio']:.1%}\n")

        # Interactive menu
        print("🔄 Interactive Menu:")
        print("  1. View full post details")
        print("  2. Refresh data")
        print("  3. Exit")

        choice = input("\nEnter your choice (1-3): ").strip()

        if choice == "1":
            if self.posts:
                print("\n📄 Full Post Details:")
                for i, post in enumerate(self.posts, 1):
                    print(f"  {i}. {post['emoji']} {post['title']}")
                    print(f"     Score: {post['score']} | Upvote Ratio: {post['upvote_ratio']:.1%}")
                    print(f"     Content: {post['content'][:200]}...")
                    print(f"     Link: https://reddit.com{post['url'].split('reddit.com')[-1]}\n")
        elif choice == "2":
            print("🔄 Refreshing data...")
            self.posts.clear()
            time.sleep(1)
            if self.scrape_reddit():
                print("✅  Data refreshed successfully!")
                self.display_interactive_console()
            else:
                print("⚠️  Refresh failed. Try again later.")
        elif choice == "3":
            print("👋 Goodbye!")
        else:
            print("❌  Invalid choice. Exiting.")

def main():
    """Main function to run the trend analyzer."""
    print("🤖 Starting ChatGPT Trends Analyzer...\n")

    analyzer = TrendAnalyzer()

    if not analyzer.scrape_reddit():
        print("⚠️  Failed to scrape data. Exiting.")
        return

    print(f"✅  Successfully scraped {len(analyzer.posts)} posts from {REDDIT_SUBREDDIT}")

    # Run visualization
    analyzer.display_interactive_console()

    # Uncomment to save chart automatically
    # analyzer.visualize_trends("trends/ChatGPT_Trends_Chart.png")

if __name__ == "__main__":
    main()

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Cosmic Particleoser</title>
    <style>
        body {
            margin: 0;
            overflow: hidden;
            background: radial-gradient(circle at 30% 30%, #0a0e2a 0%, #000000 100%);
            height: 100vh;
            display: flex;
            justify-content: center;
            align-items: center;
            color: #fff;
            font-family: 'Courier New', monospace;
            transition: background 0.5s ease;
        }

        #canvas-container {
            position: relative;
            width: 100%;
            height: 100%;
            max-width: 1200px;
            max-height: 800px;
        }

        #info {
            position: absolute;
            bottom: 20px;
            left: 20px;
            background: rgba(0, 0, 0, 0.7);
            padding: 10px 15px;
            border-radius: 5px;
            font-size: 12px;
            opacity: 0.8;
            transition: opacity 0.3s;
        }

        #info.hidden {
            opacity: 0;
        }

        canvas {
            display: block;
            background: transparent;
            border-radius: 5px;
        }
    </style>
</head>
<body>
    <div id="canvas-container">
        <canvas id="particleCanvas"></canvas>
        <div id="info">Move your mouse to create cosmic ripples | Click to add particles | Space: Toggle info</div>
    </div>

    <script>
        // ========== COSMIC PARTICLEOSER ==========
        // A particle system with mouse interaction, flocking behavior, and space-time waves
        // Features:
        // - Particles respond to mouse movement with repulsion/attraction
        // - Flocking behavior with alignment, cohesion, and separation
        // - Color transitions based on velocity and position
        // - Space-time wave effect when clicking
        // - Dynamic background and lighting effects
        // - Performance optimized with object pooling

        // Constants
        const CANVAS_SIZE = { width: 800, height: 600 };
        const PARTICLE_COUNT = 1200;
        const MAX_PARTICLES = 2000;
        const PARTICLE_RADIUS = 1.5;
        const DRAG = 0.98;
        const GRAVITY = 0.05;
        const MOUSE_SENSITIVITY = 0.0001;
        const FLOCKING_RADIUS = 100;
        const FLOCKING_WEIGHT = 0.01;
        const SEPARATION_RADIUS = 30;
        const SEPARATION_STRENGTH = 0.1;
        const WAVES = 3;
        const WAVE_SPACING = 100;
        const WAVE_AMPLITUDE = 30;
        const WAVE_DECAY = 0.95;
        const WAVE_DAMPING = 0.99;

        // State
        let canvas, ctx;
        let particles = [];
        let particlePool = [];
        let mouse = { x: 0, y: 0 };
        let waves = [];
        let showInfo = true;
        let lastClick = 0;
        let clickCount = 0;
        let animationId;
        let frameCount = 0;
        let time = 0;

        // Colors
        const colors = {
            star: ['#ffffff', '#f5f5f5', '#e0e0e0'],
            nebula: ['#4a00e0', '#8e2de2', '#dd00ff', '#ff00cc'],
            particle: ['#6bb5ff', '#90caff', '#b8e0ff'],
            background: ['#0a0e2a', '#000000']
        };

        // Utilities
        const random = (min, max) => Math.random() * (max - min) + min;
        const lerp = (a, b, t) => a + (b - a) * t;
        const distance = (x1, y1, x2, y2) => Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
        const hueToRgb = (h) => {
            const s = 1, v = 1;
            const i = Math.floor(h * 6);
            const f = h * 6 - i;
            const p = v * (1 - s);
            const q = v * (1 - f * s);
            const t = v * (1 - (1 - f) * s);
            switch (i % 6) {
                case 0: return [v, t, p];
                case 1: return [q, v, p];
                case 2: return [p, v, t];
                case 3: return [p, q, v];
                case 4: return [t, p, v];
                case 5: return [v, p, q];
                default: return [0, 0, 0];
            }
        };

        // Particle Class
        class Particle {
            constructor(x, y, pool = false) {
                this.x = x || random(CANVAS_SIZE.width / 2, CANVAS_SIZE.width);
                this.y = y || random(CANVAS_SIZE.height / 2, CANVAS_SIZE.height);
                this.vx = (Math.random() - 0.5) * 0.5;
                this.vy = (Math.random() - 0.5) * 0.5;
                this.size = PARTICLE_RADIUS + random(-0.3, 0.3);
                this.hue = random(0, 1);
                this.targetHue = this.hue;
                this.speed = distance(0, 0, this.vx, this.vy);
                this.acceleration = { x: 0, y: 0 };
                this.life = 100 + Math.floor(random(0, 50));
                this.maxLife = this.life;
                this.waveCount = 0;
                this.wavePhase = random(0, Math.PI * 2);
                this.pool = pool;
                this.id = pool ? null : Math.random().toString(36).substr(2, 9);
            }

            update(mouseX, mouseY, waves, frameCount) {
                // Apply gravity
                this.acceleration.y += GRAVITY;

                // Mouse interaction (repulsion/attraction)
                const mouseDist = distance(this.x, this.y, mouseX, mouseY);
                const mouseFactor = 1 - Math.min(mouseDist / (CANVAS_SIZE.width / 2), 1);

                // Mouse repulsion - particles move away from mouse
                this.acceleration.x -= (mouseX - this.x) * MOUSE_SENSITIVITY * mouseFactor * 2;
                this.acceleration.y -= (mouseY - this.y) * MOUSE_SENSITIVITY * mouseFactor * 2;

                // Wave forces from space-time waves
                let waveForceX = 0;
                let waveForceY = 0;
                for (let i = 0; i < waves.length; i++) {
                    const wave = waves[i];
                    const waveDist = distance(this.x, this.y, wave.x, wave.y);
                    const waveIntensity = Math.max(1 - waveDist / wave.radius, 0);

                    // Radial wave force
                    waveForceX += (wave.x - this.x) * waveIntensity * 0.01 * wave.strength;
                    waveForceY += (wave.y - this.y) * waveIntensity * 0.01 * wave.strength;

                    // Wave count tracking
                    if (waveDist < wave.radius) this.waveCount++;
                }

                this.acceleration.x += waveForceX;
                this.acceleration.y += waveForceY;

                // Flocking behavior (simplified)
                // This is a lightweight version of flocking without full boids
                const alignmentX = 0;
                const alignmentY = 0;
                const cohesionX = 0;
                const cohesionY = 0;
                const separationX = 0;
                const separationY = 0;

                // Simple separation from nearby particles (performance optimized)
                for (let i = 0; i < 3; i++) { // Limit checks for performance
                    const idx = Math.floor(random(0, particles.length) * 0.8);
                    if (idx >= 0 && idx < particles.length && particles[idx] !== this) {
                        const other = particles[idx];
                        const sepDist = distance(this.x, this.y, other.x, other.y);
                        if (sepDist < SEPARATION_RADIUS) {
                            const sepDirX = (this.x - other.x) / sepDist;
                            const sepDirY = (this.y - other.y) / sepDist;
                            separationX += sepDirX * SEPARATION_STRENGTH;
                            separationY += sepDirY * SEPARATION_STRENGTH;
                        }
                    }
                }

                // Apply forces with weights
                this.acceleration.x += alignmentX * FLOCKING_WEIGHT * 0.1;
                this.acceleration.y += alignmentY * FLOCKING_WEIGHT * 0.1;
                this.acceleration.x += cohesionX * FLOCKING_WEIGHT * 0.2;
                this.acceleration.y += cohesionY * FLOCKING_WEIGHT * 0.2;
                this.acceleration.x += separationX * 0.5;
                this.acceleration.y += separationY * 0.5;

                // Update velocity and position
                this.vx = (this.vx + this.acceleration.x) * DRAG;
                this.vy = (this.vy + this.acceleration.y) * DRAG;
                this.x += this.vx;
                this.y += this.vy;

                // Boundary wrap
                if (this.x < 0) this.x = CANVAS_SIZE.width;
                if (this.x > CANVAS_SIZE.width) this.x = 0;
                if (this.y < 0) this.y = CANVAS_SIZE.height;
                if (this.y > CANVAS_SIZE.height) this.y = 0;

                // Reset acceleration
                this.acceleration = { x: 0, y: 0 };

                // Age the particle
                this.life -= 0.1;
                if (this.life <= 0) {
                    if (this.pool) {
                        particlePool.push(this);
                    } else {
                        this.reset();
                    }
                }

                // Update color based on speed and wave exposure
                this.speed = distance(0, 0, this.vx, this.vy);
                this.targetHue = 0.5 + 0.2 * (this.speed / 2) + 0.1 * (this.waveCount / waves.length);
                this.hue = lerp(this.hue, this.targetHue, 0.02);
                this.waveCount = Math.max(0, this.waveCount - 1);

                // Update wave phase for wave motion
                this.wavePhase += 0.05;
            }

            reset(x, y) {
                if (x !== undefined) this.x = x;
                if (y !== undefined) this.y = y;
                this.vx = (Math.random() - 0.5) * 0.5;
                this.vy = (Math.random() - 0.5) * 0.5;
                this.size = PARTICLE_RADIUS + random(-0.3, 0.3);
                this.hue = random(0, 1);
                this.life = this.maxLife;
                this.waveCount = 0;
                this.wavePhase = random(0, Math.PI * 2);
            }

            draw(ctx) {
                // Calculate color with glow effect
                const color = hueToRgb(this.hue);
                const glow = 0.3 + 0.2 * (this.speed / 2) + 0.1 * (this.waveCount / 5);
                ctx.fillStyle = `rgba(${color[0] * 255}, ${color[1] * 255}, ${color[2] * 255}, ${glow})`;
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.size, 0, Math.PI * 2);
                ctx.fill();

                // Draw wave motion trail (subtle)
                if (this.waveCount > 0) {
                    const waveAlpha = 0.1 * (1 - this.radius / this.maxRadius);
                    const color = `rgba(${color[0] * 255}, ${color[1] * 255}, ${color[2] * 255}, ${waveAlpha})`;
                    ctx.strokeStyle = color;
                    ctx.lineWidth = 0.3;
                    ctx.beginPath();
                    ctx.moveTo(this.x, this.y);
                    ctx.lineTo(
                        this.x + Math.cos(this.wavePhase) * this.size * 2,
                        this.y + Math.sin(this.wavePhase) * this.size * 2
                    );
                    ctx.stroke();
                }
            }
        }

        // Wave Class
        class Wave {
            constructor(x, y) {
                this.x = x;
                this.y = y;
                this.radius = 0;
                this.maxRadius = CANVAS_SIZE.width / 2 + random(-100, 100);
                this.strength = 1 + random(-0.5, 0.5);
                this.age = 0;
                this.maxAge = 60 + Math.floor(random(0, 30));
            }

            update() {
                this.radius += (this.maxRadius - this.radius) * 0.1;
                this.strength *= WAVE_DAMPING;
                this.age++;
                if (this.age > this.maxAge) return true; // Return true if should remove
                return false;
            }

            draw(ctx) {
                // Subtle wave visualization (not drawn to particles, just for effect)
                const alpha = 0.05 * (1 - this.radius / this.maxRadius);
                const color = `rgba(100, 150, 255, ${alpha})`;
                ctx.fillStyle = color;
                ctx.beginPath();
                ctx.arc(this.x, this.y, this.radius, 0, Math.PI * 2);
                ctx.fill();
            }
        }

        // Initialize
        function init() {
            canvas = document.getElementById('particleCanvas');
            ctx = canvas.getContext('2d');

            // Set canvas size
            canvas.width = CANVAS_SIZE.width;
            canvas.height = CANVAS_SIZE.height;

            // Create initial particles
            for (let i = 0; i < PARTICLE_COUNT; i++) {
                particles.push(new Particle(undefined, undefined));
            }

            // Set up event listeners
            window.addEventListener('mousemove', handleMouseMove);
            window.addEventListener('click', handleClick);
            window.addEventListener('keydown', handleKeyDown);
            window.addEventListener('resize', handleResize);

            // Start animation
            animationId = requestAnimationFrame(animate);
        }

        // Event Handlers
        function handleMouseMove(e) {
            // Convert mouse coordinates to canvas
            const rect = canvas.getBoundingClientRect();
            mouse.x = e.clientX - rect.left;
            mouse.y = e.clientY - rect.top;
        }

        function handleClick(e) {
            const now = Date.now();
            if (now - lastClick < 200) {
                clickCount++;
                if (clickCount % 3 === 0) {
                    // Every 3 clicks, add more particles
                    addParticles(50);
                }
            } else {
                clickCount = 1;
            }
            lastClick = now;

            // Create waves on click
            for (let i = 0; i < WAVES; i++) {
                waves.push(new Wave(
                    mouse.x + Math.cos(i * Math.PI * 2 / WAVES) * 50,
                    mouse.y + Math.sin(i * Math.PI * 2 / WAVES) * 50
                ));
            }
        }

        function handleKeyDown(e) {
            if (e.code === 'Space') {
                showInfo = !showInfo;
                document.getElementById('info').classList.toggle('hidden', !showInfo);
            }
        }

        function handleResize() {
            // Simple resize handling - just redraw
            canvas.width = CANVAS_SIZE.width;
            canvas.height = CANVAS_SIZE.height;
        }

        // Particle Management
        function addParticles(count) {
            for (let i = 0; i < count; i++) {
                if (particlePool.length > 0) {
                    // Reuse particles from pool
                    const particle = particlePool.pop();
                    particle.reset(mouse.x, mouse.y);
                    particles.push(particle);
                } else if (particles.length < MAX_PARTICLES) {
                    // Create new particle
                    particles.push(new Particle(mouse.x, mouse.y));
                } else {
                    // Limit reached, just reset some existing particles
                    const idx = Math.floor(random(0, particles.length));
                    particles[idx].reset(mouse.x, mouse.y);
                }
            }
        }
    </script>
</body>
</html>
```