//! Simple increment/decrement counter with keyboard controls
//!
//! This example demonstrates:
//! - Basic Bevy + Ratatui TUI setup
//! - Keyboard event handling
//! - Event-driven architecture
//! - Proper logging setup for TUI apps
//!
//! Keys:
//! - Left/Right arrows: decrement/increment counter
//! - Esc: quit

use bevy::prelude::*;
use bevy::app::ScheduleRunnerPlugin;
use bevy_ratatui::{RatatuiContext, RatatuiPlugins, event::KeyEvent};
use ratatui::widgets::{Block, Paragraph};
use ratatui::layout::Alignment;
use ratatui::text::{Line, Text};
use ratatui::style::Stylize;
use ratatui::crossterm::event::{KeyCode, KeyEventKind};
use std::time::Duration;
use tracing::instrument;

#[derive(Resource)]
struct Counter(u32);

#[derive(Debug, Clone, Copy, Event)]
enum CounterEvent {
    Increment,
    Decrement,
}

fn main() {
    App::new()
        .add_plugins((
            // Disable LogPlugin to prevent stdout pollution in TUI
            DefaultPlugins.build().disable::<bevy::log::LogPlugin>(),
            ScheduleRunnerPlugin::run_loop(Duration::from_secs_f64(1. / 60.)),
            RatatuiPlugins::default(),
        ))
        .insert_resource(Counter(0))
        .add_event::<CounterEvent>()
        .add_systems(Startup, log_startup)
        .add_systems(PreUpdate, handle_keyboard_input)
        .add_systems(Update, handle_counter_events)
        .add_systems(PostUpdate, render_ui)
        .run();
}

#[instrument(skip_all)]
fn log_startup() {
    info!("Counter example started");
    debug!("Counter initialized at 0");
}

#[instrument(skip_all)]
fn handle_keyboard_input(
    mut keyboard_events: EventReader<KeyEvent>,
    mut counter_events: EventWriter<CounterEvent>,
    mut exit: EventWriter<AppExit>,
) {
    for event in keyboard_events.read() {
        // Skip release events
        if event.kind == KeyEventKind::Release {
            continue;
        }

        match event.code {
            KeyCode::Left => {
                debug!("Decrement key pressed");
                counter_events.write(CounterEvent::Decrement);
            }
            KeyCode::Right => {
                debug!("Increment key pressed");
                counter_events.write(CounterEvent::Increment);
            }
            KeyCode::Esc => {
                info!("Exit key pressed");
                exit.write(AppExit::Success);
            }
            _ => (),
        }
    }
}

#[instrument(skip_all)]
fn handle_counter_events(
    mut counter: ResMut<Counter>,
    mut events: EventReader<CounterEvent>,
) {
    for event in events.read() {
        match event {
            CounterEvent::Increment => {
                counter.0 += 1;
                info!("Counter incremented to {}", counter.0);
            }
            CounterEvent::Decrement => {
                counter.0 = counter.0.saturating_sub(1);
                info!("Counter decremented to {}", counter.0);
            }
        }
    }
}

#[instrument(skip_all)]
fn render_ui(counter: Res<Counter>, mut ratatui: ResMut<RatatuiContext>) {
    let _ = ratatui.draw(|frame| {
        let area = frame.area();

        let title = Line::from(" My Great TUI ".bold());
        let instructions = Line::from(vec![
            " Decrement ".into(),
            "<Left>".blue().bold(),
            " Increment ".into(),
            "<Right>".blue().bold(),
            " Quit ".into(),
            "<Esc> ".blue().bold(),
        ]);

        let block = Block::bordered()
            .title(title.centered())
            .title_bottom(instructions.centered());

        let counter_text = Text::from(vec![Line::from(vec![
            "Value: ".into(),
            counter.0.to_string().yellow(),
        ])]);

        let paragraph = Paragraph::new(counter_text)
            .alignment(Alignment::Center)
            .block(block);

        frame.render_widget(paragraph, area);
    });
}