A!leys Galerie

```csharp
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
using System.Linq;
using DG.Tweening;
using UnityEngine.EventSystems;

[RequireComponent(typeof(GraphCanvas))]
[ExecuteAlways]
public class DynamicTweenFlow : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    [SerializeField] private float minNodeSize = 30f;
    [SerializeField] private float maxNodeSize = 100f;
    [SerializeField] private Color defaultNodeColor = new Color(0.2f, 0.6f, 0.9f);
    [SerializeField] private Color highlightColor = Color.yellow;
    [SerializeField] private Color warningColor = Color.red;
    [SerializeField] private float connectionThickness = 2f;
    [SerializeField] private float minConnectionDistance = 50f;
    [SerializeField] private float dragSpeedMultiplier = 0.5f;
    [SerializeField] private float zoomSpeed = 2f;
    [SerializeField] private float minZoom = 0.1f;
    [SerializeField] private float maxZoom = 5f;
    [SerializeField] private AnimationCurve zoomCurve;

    private GraphCanvas canvas;
    private List<Node> nodes = new List<Node>();
    private List<Connection> connections = new List<Connection>();
    private Node selectedNode;
    private Vector2 lastDragPosition;
    private float currentZoom = 1f;
    private RectTransform canvasRect;
    private bool isDragging = false;
    private bool isGeneratingCode = false;
    private string generatedCode;

    private enum NodeType { Tween, Property, Event, None }
    private enum ConnectionType { Tween, Flow, None }

    [System.Serializable]
    public class Node
    {
        public Vector2 position;
        public NodeType type;
        public string name = "New Node";
        public string propertyPath;
        public Ease easeType;
        public float duration = 1f;
        public float delay = 0f;
        public bool isLoop;
        public bool isActive = true;
        public Color color;
        public RectTransform rectTransform;
        public List<int> incomingConnections = new List<int>();
        public List<int> outgoingConnections = new List<int>();

        public Node(NodeType type, string name = "New Node")
        {
            this.type = type;
            this.name = name;
            this.color = defaultNodeColor;
            this.easeType = Ease.InOutQuad;
        }

        public void UpdateVisuals()
        {
            if (rectTransform == null) return;

            // Dynamic size based on content and type
            float size = minNodeSize + (type == NodeType.Property ? 20f : 0);
            size = Mathf.Clamp(size, minNodeSize, maxNodeSize);
            rectTransform.sizeDelta = new Vector2(size, size);

            // Update color based on state
            if (incomingConnections.Count == 0 && outgoingConnections.Count == 0)
                color = warningColor;
            else if (incomingConnections.Count > 0)
                color = defaultNodeColor;
            else if (selectedNode == this)
                color = highlightColor;
            else
                color = defaultNodeColor * 0.8f;

            GetComponent<Image>().color = color;

            // Update text based on type
            Text text = GetComponentInChildren<Text>();
            if (text == null) return;

            switch (type)
            {
                case NodeType.Tween:
                    text.text = name + "\n" + $"Dur: {duration:F1}s\nEase: {easeType}";
                    break;
                case NodeType.Property:
                    text.text = propertyPath;
                    break;
                case NodeType.Event:
                    text.text = name;
                    break;
                default:
                    text.text = name;
                    break;
            }
        }
    }

    [System.Serializable]
    public class Connection
    {
        public int fromNodeIndex;
        public int toNodeIndex;
        public ConnectionType type;
        public LineRenderer lineRenderer;
        public bool isValid = true;

        public Connection(int from, int to, ConnectionType type)
        {
            fromNodeIndex = from;
            toNodeIndex = to;
            this.type = type;
            CreateLineRenderer();
        }

        private void CreateLineRenderer()
        {
            GameObject lineObj = new GameObject("ConnectionLine_" + fromNodeIndex + "_" + toNodeIndex);
            lineObj.transform.SetParent(transform);
            lineRenderer = lineObj.AddComponent<LineRenderer>();
            lineRenderer.startWidth = connectionThickness;
            lineRenderer.endWidth = connectionThickness;
            lineRenderer.positionCount = 2;
            lineRenderer.useWorldSpace = true;
            lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
            lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
        }

        public void UpdateLine()
        {
            if (lineRenderer == null) return;

            if (fromNodeIndex >= nodes.Count || toNodeIndex >= nodes.Count)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Node fromNode = nodes[fromNodeIndex];
            Node toNode = nodes[toNodeIndex];

            if (fromNode.rectTransform == null || toNode.rectTransform == null)
            {
                Destroy(lineRenderer.gameObject);
                return;
            }

            Vector3[] positions = new Vector3[2];
            positions[0] = fromNode.rectTransform.rect.center + fromNode.rectTransform.anchoredPosition;
            positions[1] = toNode.rectTransform.rect.center + toNode.rectTransform.anchoredPosition;
            lineRenderer.SetPositions(positions);

            // Check if connection is valid (not overlapping nodes)
            isValid = Vector2.Distance(positions[0], positions[1]) > minConnectionDistance;

            if (!isValid)
            {
                lineRenderer.startColor = warningColor;
                lineRenderer.endColor = warningColor;
            }
            else
            {
                lineRenderer.startColor = type == ConnectionType.Tween ? Color.green : Color.blue;
                lineRenderer.endColor = type == ConnectionType.Tween ? Color.green : Color.blue;
            }
        }

        public void DestroyLine()
        {
            if (lineRenderer != null)
                Destroy(lineRenderer.gameObject);
        }
    }

    private void Awake()
    {
        if (canvas == null)
            canvas = GetComponent<GraphCanvas>();

        if (canvasRect == null)
            canvasRect = canvas.GetComponent<RectTransform>();

        // Initialize with default nodes
        if (nodes.Count == 0)
        {
            CreateDefaultNodes();
        }
    }

    private void CreateDefaultNodes()
    {
        // Property node (start)
        Node startNode = new Node(NodeType.Property, "Start Position");
        startNode.propertyPath = "transform.localPosition";
        nodes.Add(startNode);

        // Tween node
        Node tweenNode = new Node(NodeType.Tween, "Move Tween");
        tweenNode.duration = 2f;
        nodes.Add(tweenNode);

        // Property node (end)
        Node endNode = new Node(NodeType.Property, "End Position");
        endNode.propertyPath = "transform.localPosition";
        nodes.Add(endNode);

        // Create connections
        connections.Add(new Connection(0, 1, ConnectionType.Tween));
        connections.Add(new Connection(1, 2, ConnectionType.Flow));

        UpdateAllNodes();
    }

    private void UpdateAllNodes()
    {
        foreach (Node node in nodes)
        {
            if (node.rectTransform == null)
            {
                CreateNodeUI(node);
            }
            node.UpdateVisuals();
        }

        foreach (Connection conn in connections)
        {
            conn.UpdateLine();
        }

        GenerateCode();
    }

    private void CreateNodeUI(Node node)
    {
        GameObject nodeObj = new GameObject(node.name);
        nodeObj.transform.SetParent(canvas.transform);
        node.rectTransform = nodeObj.AddComponent<RectTransform>();
        node.rectTransform.anchorMin = Vector2.zero;
        node.rectTransform.anchorMax = Vector2.one;
        node.rectTransform.sizeDelta = new Vector2(minNodeSize, minNodeSize);
        node.rectTransform.anchoredPosition = node.position;

        Image nodeImage = nodeObj.AddComponent<Image>();
        nodeImage.color = node.color;
        nodeImage.preserveAspect = true;

        // Add label
        GameObject labelObj = new GameObject("Label");
        labelObj.transform.SetParent(nodeObj.transform);
        Text label = labelObj.AddComponent<Text>();
        label.alignment = TextAnchor.MiddleCenter;
        label.fontSize = Mathf.RoundToInt(minNodeSize * 0.6f);
        label.color = Color.white;
        nodeObj.AddComponent<Node>().Initialize(node, label);

        // Add drag handler
        nodeObj.AddComponent<NodeDragHandler>().Initialize(node);
    }

    private void GenerateCode()
    {
        if (isGeneratingCode) return;
        isGeneratingCode = true;

        generatedCode = GenerateTweenSequence();
        Debug.Log("Generated Tween Code:\n" + generatedCode);

        isGeneratingCode = false;
    }

    private string GenerateTweenSequence()
    {
        string code = "using DG.Tweening;\nusing UnityEngine;\n\n";

        if (connections.Count == 0)
        {
            code += "// No valid tween sequence found. Create connections to generate code.\n";
            return code;
        }

        // Find the starting node (node with no incoming connections)
        Node startNode = nodes.FirstOrDefault(n => n.incomingConnections.Count == 0);
        if (startNode == null)
        {
            code += "// No starting node found (node with no incoming connections).\n";
            return code;
        }

        code += "public class GeneratedTweenSequence : MonoBehaviour\n{\n";
        code += "    void Start()\n    {\n";

        code += $"        // Start tween from {startNode.name}\n";
        if (startNode.type == NodeType.Property)
        {
            code += $"        Tween tween = DOTween.To(() => transform.{startNode.propertyPath}, x => transform.{startNode.propertyPath} = x,\n";
            code += $"            new Vector3(0, 0, 0), // Default target (will be replaced)\n";
            code += $"            {startNode.duration}.f).SetEase({GetEaseName(startNode.easeType)}).SetDelay({startNode.delay})\n";

            // Find all tween nodes connected to this
            foreach (int outgoingIndex in startNode.outgoingConnections)
            {
                Connection conn = connections[outgoingIndex];
                if (conn.type == ConnectionType.Tween)
                {
                    Node tweenNode = nodes[conn.toNodeIndex];
                    code += $".OnComplete(() =>\n" +
                            $"    DOTween.To(() => transform.{tweenNode.propertyPath}, x => transform.{tweenNode.propertyPath} = x,\n" +
                            $"        new Vector3({GetRandomVector3()}), // Target position\n" +
                            $"        {tweenNode.duration}.f).SetEase({GetEaseName(tweenNode.easeType)})\n";
                }
            }
        }

        code += ";\n";
        code += "    }\n";
        code += "}\n";

        return code;
    }

    private string GetEaseName(Ease ease)
    {
        return ease switch
        {
            Ease.InQuad => "Ease.InQuad",
            Ease.OutQuad => "Ease.OutQuad",
            Ease.InOutQuad => "Ease.InOutQuad",
            Ease.InExpo => "Ease.InExpo",
            Ease.OutExpo => "Ease.OutExpo",
            Ease.InOutExpo => "Ease.InOutExpo",
            Ease.InCirc => "Ease.InCirc",
            Ease.OutCirc => "Ease.OutCirc",
            Ease.InOutCirc => "Ease.InOutCirc",
            _ => "Ease.Linear"
        };
    }

    private Vector3 GetRandomVector3()
    {
        return new Vector3(Random.Range(-5, 5), Random.Range(-5, 5), Random.Range(-5, 5));
    }

    #region UI Interactions

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (!canvas.IsPointerOverCanvas(eventData))
            return;

        lastDragPosition = eventData.position;
        isDragging = true;
    }

    public void OnDrag(PointerEventData eventData)
    {
        if (!isDragging || !canvas.IsPointerOverCanvas(eventData))
            return;

        Vector2 delta = eventData.position - lastDragPosition;
        lastDragPosition = eventData.position;

        // Handle zoom with pinch (mobile) or mouse wheel (desktop)
        if (eventData.pointerCount > 1)
        {
            float pinchDelta = GetPinchDelta(eventData);
            ZoomCamera(pinchDelta * zoomSpeed);
        }
        else if (Input.GetAxis("Mouse ScrollWheel") != 0)
        {
            ZoomCamera(Input.GetAxis("Mouse ScrollWheel") * zoomSpeed);
        }
        else
        {
            // Pan the camera
            Vector2 pan = Camera.main.ScreenToViewportPoint(delta) * currentZoom;
            camera.transform.Translate(new Vector3(pan.x, pan.y, 0), Space.World);
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        isDragging = false;
    }

    private float GetPinchDelta(PointerEventData eventData)
    {
        if (eventData.pointerCount < 2) return 0f;

        Vector2 firstPos, secondPos;
        eventData.GetPosition(out firstPos);
        eventData.GetPosition(out secondPos, 1);

        Vector2 prevFirst, prevSecond;
        eventData.GetPreviousPosition(out prevFirst);
        eventData.GetPreviousPosition(out prevSecond, 1);

        float prevDistance = Vector2.Distance(prevFirst, prevSecond);
        float currentDistance = Vector2.Distance(firstPos, secondPos);

        return currentDistance / (prevDistance + 0.001f);
    }

    private void ZoomCamera(float zoomFactor)
    {
        zoomFactor = Mathf.Clamp(zoomFactor, -1f, 1f);
        currentZoom = Mathf.Clamp(currentZoom + zoomFactor, minZoom, maxZoom);

        // Apply zoom curve for smoother feel
        currentZoom = Mathf.Clamp(zoomCurve.Evaluate(currentZoom), minZoom, maxZoom);

        // Update camera orthographic size
        Camera.main.orthographicSize = currentZoom * 5f;

        // Update all node positions to maintain relative positioning
        Vector2 center = canvasRect.rect.center;
        foreach (Node node in nodes)
        {
            if (node.rectTransform != null)
            {
                Vector2 newPos = node.rectTransform.anchoredPosition;
                newPos.x = Mathf.Lerp(newPos.x, center.x, 0.1f * currentZoom);
                newPos.y = Mathf.Lerp(newPos.y, center.y, 0.1f * currentZoom);
                node.rectTransform.anchoredPosition = newPos;
            }
        }
    }

    #endregion

    #region Node Management

    public void AddNode(NodeType type, Vector2 position = default)
    {
        Node newNode = new Node(type);
        newNode.position = position == default ? Camera.main.ScreenToViewportPoint(Input.mousePosition) * 1000f : position;
        nodes.Add(newNode);
        CreateNodeUI(newNode);
        UpdateAllNodes();
    }

    public void RemoveNode(int index)
    {
        if (index < 0 || index >= nodes.Count) return;

        // Remove all connections to/from this node
        connections.RemoveAll(c => c.fromNodeIndex == index || c.toNodeIndex == index);

        // Update other nodes' connection lists
        foreach (Node node in nodes)
        {
            node.incomingConnections.Remove(index);
            node.outgoingConnections.Remove(index);
        }

        Destroy(nodes[index].rectTransform.gameObject);
        nodes.RemoveAt(index);
        UpdateAllNodes();
    }

    public void AddConnection(int fromIndex, int toIndex, ConnectionType type)
    {
        if (fromIndex < 0 || fromIndex >= nodes.Count || toIndex < 0 || toIndex >= nodes.Count) return;
        if (fromIndex == toIndex) return; // No self connections

        // Check if connection already exists
        if (connections.Exists(c => c.fromNodeIndex == fromIndex && c.toNodeIndex == toIndex))
            return;

        connections.Add(new Connection(fromIndex, toIndex, type));
        nodes[fromIndex].outgoingConnections.Add(connections.Count - 1);
        nodes[toIndex].incomingConnections.Add(connections.Count - 1);
        UpdateAllNodes();
    }

    public void RemoveConnection(int connectionIndex)
    {
        if (connectionIndex < 0 || connectionIndex >= connections.Count) return;

        Connection conn = connections[connectionIndex];
        nodes[conn.fromNodeIndex].outgoingConnections.Remove(connectionIndex);
        nodes[conn.toNodeIndex].incomingConnections.Remove(connectionIndex);
        conn.DestroyLine();
        connections.RemoveAt(connectionIndex);
        UpdateAllNodes();
    }

    #endregion

    #region Editor Tools

    public void ResetGraph()
    {
        foreach (Connection conn in connections)
        {
            conn.DestroyLine();
        }
        connections.Clear();

        foreach (Node node in nodes)
        {
            Destroy(node.rectTransform.gameObject);
        }
        nodes.Clear();

        CreateDefaultNodes();
    }

    public void ExportCodeToFile()
    {
        if (string.IsNullOrEmpty(generatedCode))
        {
            Debug.LogWarning("No code to export. Create a valid tween sequence first.");
            return;
        }

        string filePath = System.IO.Path.Combine(Application.persistentDataPath, "GeneratedTweenSequence.cs");
        System.IO.File.WriteAllText(filePath, generatedCode);
        Debug.Log($"Code exported to: {filePath}");
    }

    #endregion

#!/usr/bin/env node

const fs = require('fs');
const readline = require('readline');
const Ajv = require('ajv');
const chalk = require('chalk');

const ajv = new Ajv({
  allErrors: true,
  removeAdditional: true,
  verbose: true
});

// Enhance default AJV with our custom error messages
ajv.addFormat('email', /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/);

// Creative error message generator
function generateSparkError(error, data) {
  const errors = error.errors || [error];
  const messages = errors.map(err => {
    const path = err.dataPath ? data.dataPath : '';
    let message = '';

    // Determine error type and generate creative message
    switch (err.params?.type) {
      case 'required':
        message = `🌑 ${path} is missing! Like a ghost, it haunts the schema, demanding to be present.`;
        break;
      case 'additionalProperties':
        message = `🤖 ${path} is not allowed here! The schema bot detected an unauthorized property trying to sneak in.`;
        break;
      case 'type':
        switch (err.params?.type) {
          case 'string':
            message = `🧙‍♀️ Expected a string at ${path} but found something else. Maybe it was cast by an evil spell?`;
            break;
          case 'number':
            message = `🧮 Expected a number at ${path} but found a non-numeric value. Numbers should be crisp like a math teacher's grading.`;
            break;
          case 'array':
            message = `🧩 Expected an array at ${path} but found something that doesn't like to be counted.`;
            break;
          case 'object':
            message = `🌍 Expected an object at ${path} but found something that doesn't like to be structured.`;
            break;
          case 'boolean':
            message = `⚡ Expected a boolean at ${path} but found something that can't decide between true or false.`;
            break;
        }
        break;
      case 'enum':
        message = `🎭 ${path} should be one of [${err.params.allowedValues.join(', ')}] but tried to be something else. Maybe it's an imposter?`;
        break;
      case 'pattern':
        message = `🔍 ${path} has an invalid pattern. The regex guardian won't let unknown patterns pass.`;
        break;
      case 'format':
        if (err.params?.type === 'email') {
          message = `✉️ ${path} is not a valid email address. It looks like it got lost in the digital void.`;
        }
        break;
      case 'minLength':
        message = `📏 ${path} is too short! It needs at least ${err.params.limit} characters to be considered valid.`;
        break;
      case 'maxLength':
        message = `📏 ${path} is too long! It needs to shrink down to ${err.params.limit} characters or less.`;
        break;
      case 'minimum':
        message = `📉 ${path} is too small! It needs to be at least ${err.params.limit}. Maybe it's still in its embryonic state?`;
        break;
      case 'maximum':
        message = `📈 ${path} is too big! It needs to shrink down to ${err.params.limit} or less.`;
        break;
      default:
        message = `❓ ${path} has an issue that the SchemaSpark couldn't decode. Try asking a human or a very smart robot.`;
    }

    // Add additional context if available
    if (err.params?.type === 'additionalProperties' && err.params?.additionalProperty) {
      message += ` The offender is: ${err.params.additionalProperty}`;
    }

    return message;
  });

  return {
    valid: false,
    errors: messages,
    path: error.dataPath || ''
  };
}

async function main() {
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  console.log(chalk.yellow bold('=== SchemaSpark - JSON Schema Validator with AI-Inspired Error Messages ==='));
  console.log(chalk.blue('Enter your JSON data (press Ctrl+C to exit):\n'));

  const jsonData = await new Promise((resolve, reject) => {
    let data = '';
    rl.on('line', (line) => { data += line; });
    rl.on('close', () => resolve(data));
  }).catch(() => {
    console.log(chalk.red('\nValidation cancelled by user.'));
    process.exit(0);
  });

  try {
    const schemaPath = process.argv[2];
    if (!schemaPath) {
      console.error(chalk.red('Error: Please provide a schema file path as an argument.'));
      console.log(chalk.gray('Usage: node schemaSpark.js <path-to-schema.json>'));
      process.exit(1);
    }

    if (!fs.existsSync(schemaPath)) {
      console.error(chalk.red(`Error: Schema file not found at ${schemaPath}`));
      process.exit(1);
    }

    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
    const data = JSON.parse(jsonData);

    const validate = ajv.compile(schema);
    const isValid = validate(data);

    if (isValid) {
      console.log(chalk.green('✨ Sparkle! Your data passed all validation checks with flying colors! 🌟'));
      console.log(chalk.green('The SchemaSpark is proud of your perfect JSON structure!'));
    } else {
      const sparkError = generateSparkError(validate, data);
      console.log(chalk.red(`\n⚠️  SchemaSpark Detected ${sparkError.errors.length} Issues:`));
      sparkError.errors.forEach((error, index) => {
        console.log(`  ${index + 1}. ${error}`);
      });
      console.log('\n💡 Tips:');
      console.log('  - Check the paths mentioned in the errors');
      console.log('  - Ensure required fields are present');
      console.log('  - Verify all data types match the schema');
      console.log('  - Keep strings to the correct length');
    }
  } catch (err) {
    if (err instanceof SyntaxError) {
      console.error(chalk.red(`\n🌑 Syntax Error: ${err.message}`));
      console.log(chalk.red('Please ensure your JSON is properly formatted.'));
    } else {
      console.error(chalk.red(`\n🤖 Unexpected Error: ${err.message}`));
    }
    process.exit(1);
  } finally {
    rl.close();
  }
}

main();

// Import required modules
const readline = require('readline');
const fs = require('fs').promises;
const path = require('path');

// Main module for the simulation
const SkyTintSimulator = (() => {
  // Private variables
  let currentTime = 12; // 12:00 PM in 24-hour format (0-24)
  let skyTintState = {
    day: { hue: 210, saturation: 0.8, brightness: 0.9 },
    dusk: { hue: 220, saturation: 0.9, brightness: 0.7 },
    night: { hue: 240, saturation: 1.0, brightness: 0.2 },
    dawn: { hue: 190, saturation: 0.85, brightness: 0.6 },
  };
  let weatherEffect = 'clear';

  // Time constants (in hours)
  const DAWN_DURATION = 2;
  const DAY_DURATION = 8;
  const DUSK_DURATION = 3;
  const NIGHT_DURATION = 11;

  // Load state from localStorage
  const loadState = async () => {
    try {
      const savedState = localStorage.getItem('skyTintState');
      if (savedState) {
        const parsedState = JSON.parse(savedState);
        currentTime = parsedState.currentTime || 12;
        skyTintState = { ...skyTintState, ...parsedState.skyTintState };
        weatherEffect = parsedState.weatherEffect || 'clear';
      }
    } catch (e) {
      console.error('Error loading state:', e);
    }
  };

  // Save state to localStorage
  const saveState = () => {
    try {
      const stateToSave = {
        currentTime,
        skyTintState,
        weatherEffect,
      };
      localStorage.setItem('skyTintState', JSON.stringify(stateToSave));
    } catch (e) {
      console.error('Error saving state:', e);
    }
  };

  // Calculate current sky tint based on time and weather
  const calculateTint = () => {
    const timeInHours = currentTime;
    const isDaytime = timeInHours >= 6 && timeInHours <= 18;
    const isDawn = timeInHours >= 4 && timeInHours < 6;
    const isDusk = timeInHours >= 18 && timeInHours < 20;
    const isNight = timeInHours >= 20 || timeInHours < 4;

    let baseTint = skyTintState.day;
    if (isDawn) {
      baseTint = skyTintState.dawn;
    } else if (isDusk) {
      baseTint = skyTintState.dusk;
    } else if (isNight) {
      baseTint = skyTintState.night;
    }

    // Apply weather effect with a 30% chance
    if (Math.random() < 0.3 && weatherEffect !== 'clear') {
      switch (weatherEffect) {
        case 'rain':
          baseTint.hue = (baseTint.hue + 20) % 360;
          baseTint.saturation *= 0.9;
          baseTint.brightness *= 0.8;
          break;
        case 'snow':
          baseTint.hue = (baseTint.hue + 10) % 360;
          baseTint.saturation *= 0.7;
          baseTint.brightness *= 0.6;
          break;
        case 'fog':
          baseTint.hue = (baseTint.hue + 30) % 360;
          baseTint.saturation *= 0.5;
          baseTint.brightness *= 0.4;
          break;
      }
    }

    return {
      hue: Math.round(baseTint.hue),
      saturation: Math.round(baseTint.saturation * 100) / 100,
      brightness: Math.round(baseTint.brightness * 100) / 100,
    };
  };

  // Advance time by a specified amount (in hours)
  const advanceTime = (hours) => {
    currentTime = (currentTime + hours) % 24;
    saveState();
  };

  // Display the current sky tint in a readable format
  const displayTint = () => {
    const tint = calculateTint();
    const timeOfDay = getTimeOfDay();

    console.log('\x1b[1mCurrent Sky Tint:\x1b[0m');
    console.log(`  Time of Day: ${timeOfDay}`);
    console.log(`  Hue: ${tint.hue}° (${hsvToColorName(tint.hue)})`);
    console.log(`  Saturation: ${tint.saturation * 100}%`);
    console.log(`  Brightness: ${tint.brightness * 100}%`);
    console.log(`  Weather: ${weatherEffect.charAt(0).toUpperCase() + weatherEffect.slice(1)}`);
    console.log('\x1b[1mSimulation State:\x1b[0m');
    console.log(`  Current Time: ${currentTime.toFixed(1)}:00`);
    console.log(`  Total Duration: ${DAWN_DURATION + DAY_DURATION + DUSK_DURATION + NIGHT_DURATION} hours`);
    console.log(`  Current Phase: ${getCurrentPhase()}`);
  };

  // Helper to get time of day
  const getTimeOfDay = () => {
    const timeInHours = currentTime;
    if (timeInHours >= 4 && timeInHours < 6) return 'Dawn';
    if (timeInHours >= 6 && timeInHours < 18) return 'Day';
    if (timeInHours >= 18 && timeInHours < 20) return 'Dusk';
    return 'Night';
  };

  // Helper to get current phase
  const getCurrentPhase = () => {
    const timeInHours = currentTime;
    if (timeInHours >= 4 && timeInHours < 6) return 'Dawn';
    if (timeInHours >= 6 && timeInHours < 18) return 'Day';
    if (timeInHours >= 18 && timeInHours < 20) return 'Dusk';
    return 'Night';
  };

  // Helper to convert hue to color name
  const hsvToColorName = (hue) => {
    const colors = [
      'Red', 'Orange', 'Yellow', 'Green', 'Blue', 'Indigo', 'Violet', 'Magenta'
    ];
    const index = Math.floor(hue / 30) % colors.length;
    return colors[index];
  };

  // Public API
  return {
    loadState,
    saveState,
    calculateTint,
    advanceTime,
    displayTint,
    getCurrentTime: () => currentTime,
    setWeatherEffect: (effect) => {
      if (['clear', 'rain', 'snow', 'fog'].includes(effect)) {
        weatherEffect = effect;
        saveState();
      }
    },
  };
})();

// Initialize the simulator
const simulator = SkyTintSimulator;

// Initialize readline interface
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

// Main command loop
async function main() {
  await simulator.loadState();
  simulator.displayTint();

  console.log('\n\x1b[1mCommands:\x1b[0m');
  console.log('  - "advance [hours]": Advance time by specified hours');
  console.log('  - "set weather [effect]": Set weather effect (clear, rain, snow, fog)');
  console.log('  - "reset": Reset to 12:00 PM');
  console.log('  - "exit": Quit the simulation');
  console.log('  - "display": Display current tint');

  rl.on('line', async (line) => {
    const args = line.trim().split(' ');
    const command = args[0].toLowerCase();

    switch (command) {
      case 'advance':
        if (args.length > 1 && !isNaN(parseFloat(args[1]))) {
          simulator.advanceTime(parseFloat(args[1]));
          simulator.displayTint();
        } else {
          console.log('Usage: advance [hours]');
        }
        break;
      case 'set':
        if (args.length > 2 && args[1].toLowerCase() === 'weather') {
          const effect = args[2].toLowerCase();
          if (['clear', 'rain', 'snow', 'fog'].includes(effect)) {
            simulator.setWeatherEffect(effect);
            simulator.displayTint();
          } else {
            console.log('Invalid weather effect. Use: clear, rain, snow, fog');
          }
        } else {
          console.log('Usage: set weather [effect]');
        }
        break;
      case 'reset':
        simulator.advanceTime(0 - simulator.getCurrentTime());
        simulator.displayTint();
        break;
      case 'exit':
        rl.close();
        break;
      case 'display':
        simulator.displayTint();
        break;
      default:
        console.log('Unknown command. Available commands: advance, set weather, reset, exit, display');
    }
  });

  rl.on('close', () => {
    console.log('\nExiting simulation. State saved.');
    process.exit(0);
  });
}

// Start the simulation
main().catch(console.error);

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