use client_application::ClientApp;
use client_domain::{BoundingBox, DisplayPort, FontMetrics, RenderEngine, ThemeConfig};
use display_terminal::TerminalDisplay;
use domain::DisplayHint;
use protocol::decode_server_message;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
use tcp_client::StdTcpClient;
use client_domain::NetworkPort;

fn main() {
    let screen = BoundingBox::screen(240, 320);
    let mut app = ClientApp::new(screen);
    let mut display = TerminalDisplay::new();
    let metrics = FontMetrics {
        small: (6, 10),
        large: (10, 20),
    };
    let mut engine = RenderEngine::new(metrics, ThemeConfig::default());

    println!("=== K-Frame Desktop Client ===");
    println!("Screen: {}x{}", screen.width, screen.height);

    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let server_addr = "127.0.0.1:2699";
        let mut net = StdTcpClient::new();

        loop {
            if !net.is_connected() {
                println!("[NET] Connecting to {server_addr}...");
                match net.connect(server_addr) {
                    Ok(()) => println!("[NET] Connected!"),
                    Err(e) => {
                        println!("[NET] Connection failed: {e}, retrying in 2s...");
                        thread::sleep(Duration::from_secs(2));
                        continue;
                    }
                }
            }

            match net.receive() {
                Ok(Some(payload)) => match decode_server_message(&payload) {
                    Ok(msg) => {
                        let _ = tx.send(msg);
                    }
                    Err(e) => println!("[NET] Decode error: {e}"),
                },
                Ok(None) => {
                    thread::sleep(Duration::from_millis(50));
                }
                Err(e) => {
                    println!("[NET] Receive error: {e}, reconnecting...");
                    let _ = net.disconnect();
                    thread::sleep(Duration::from_secs(2));
                }
            }
        }
    });

    println!("[RENDER] Render loop started");

    loop {
        match rx.recv_timeout(Duration::from_millis(100)) {
            Ok(msg) => {
                let repaints = app.handle_message(msg);

                if app.take_theme_changed() {
                    engine.set_theme(app.theme().clone());
                }

                if !repaints.is_empty() {
                    println!("\n--- Repaint ({} widgets) ---", repaints.len());
                    let bg = engine.theme().background;
                    for cmd in &repaints {
                        display.fill_rect(cmd.bounds, bg).unwrap();

                        let hint: DisplayHint = cmd.display_hint.clone().into();
                        let data: Vec<(String, domain::Value)> = cmd.state.data
                            .iter()
                            .map(|kv| (kv.key.clone(), kv.value.clone().into()))
                            .collect();

                        let draw_cmds = engine.render_widget(&hint, &data, cmd.bounds, 0);
                        for dc in &draw_cmds {
                            display.draw_text_span(&dc.text, dc.x, dc.y, dc.color, dc.font).unwrap();
                        }
                    }
                    display.flush().unwrap();
                }
            }
            Err(mpsc::RecvTimeoutError::Timeout) => {}
            Err(mpsc::RecvTimeoutError::Disconnected) => break,
        }
    }
}