//! Workspaces survive a new frontend, and keyboard input follows real widget focus.

use std::sync::Arc;

use effectcraft_engine::Session;
use effectcraft_engine::config::{ConfigStore, DirConfig, MemoryConfig};
use effectcraft_ui_egui::EffectcraftApp;
use effectcraft_ui_egui::dock::{DockNode, PanelKind, SplitSize};
use effectcraft_ui_egui::state::Tool;
use egui::{Event, Id, Key, Modifiers, vec2};
use egui_kittest::Harness;
use serde_json::json;

#[test]
fn named_and_current_workspaces_survive_frontend_restart() {
    let store = Arc::new(MemoryConfig::default());
    let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
    app.ui.dock = DockNode::Split {
        vertical: false,
        size: SplitSize::FixedA(345.0),
        a: Box::new(DockNode::Tabs { panels: vec![PanelKind::Project], active: 0 }),
        b: Box::new(DockNode::Tabs { panels: vec![PanelKind::Composition, PanelKind::Layer], active: 1 }),
    };
    let ctx = egui::Context::default();
    effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name": "Restart layout"})).unwrap();
    let saved = app.ui.dock.clone();
    if let DockNode::Split { size, .. } = &mut app.ui.dock {
        *size = SplitSize::FixedA(390.0);
    }
    app.ui.focused = PanelKind::Layer;
    let current = app.ui.dock.clone();
    eframe::App::on_exit(&mut app);
    assert!(store.read("workspaces.json").is_some(), "workspace data must reach the configured store");
    let mut restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });
    assert_eq!(restarted.ui.workspace, "Restart layout");
    assert_eq!(restarted.ui.dock, current, "restore current unsaved divider changes independently of the named snapshot");
    assert_eq!(restarted.ui.saved_workspaces.get("Restart layout"), Some(&saved));
    assert_eq!(restarted.ui.focused, PanelKind::Layer);
    restarted.set_workspace("Default");
    restarted.set_workspace("Restart layout");
    assert_eq!(restarted.ui.dock, saved, "the named snapshot is separately available after restart");
}

fn key(h: &mut Harness<'_, EffectcraftApp>, key: Key, modifiers: Modifiers) {
    h.event(Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers });
    h.step();
    h.event(Event::Key { key, physical_key: None, pressed: false, repeat: false, modifiers });
    h.step();
    h.run_steps(2);
}

fn scratch_dir(label: &str) -> std::path::PathBuf {
    static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
    let id = NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    let path = std::env::temp_dir().join(format!("effectcraft-workspace-{label}-{}-{id}", std::process::id()));
    std::fs::create_dir(&path).unwrap();
    path
}

#[test]
fn native_config_read_is_byte_bounded_and_reports_errors() {
    let dir = scratch_dir("bounded-read");
    let config = DirConfig::new(&dir);
    assert!(config.read_bounded("missing", 4).unwrap().is_none());
    std::fs::write(dir.join("entry"), "é").unwrap();
    assert_eq!(config.read_bounded("entry", 2).unwrap().as_deref(), Some("é"));
    assert_eq!(config.read_bounded("entry", 1).unwrap_err().kind(), std::io::ErrorKind::InvalidData);
    std::fs::write(dir.join("entry"), [0xff, 0xfe]).unwrap();
    assert_eq!(config.read_bounded("entry", 4).unwrap_err().kind(), std::io::ErrorKind::InvalidData);
    std::fs::create_dir(dir.join("folder")).unwrap();
    assert!(config.read_bounded("folder", 4).is_err());
    std::fs::remove_dir_all(dir).unwrap();
}

#[test]
fn unreadable_native_workspace_is_preserved_after_later_layout_changes() {
    for bytes in
        [vec![0xff, 0xfe], vec![b' '; 1024 * 1024 + 1], b"{".to_vec(), serde_json::to_vec(&json!({"version":2,"workspaces":{},"floating":{}})).unwrap()]
    {
        let dir = scratch_dir("preserve");
        let path = dir.join("workspaces.json");
        std::fs::write(&path, &bytes).unwrap();
        let mut app = EffectcraftApp::new(Session { config: Some(Arc::new(DirConfig::new(&dir))), ..Default::default() });
        let ctx = egui::Context::default();
        assert!(effectcraft_ui_egui::control::inspect(&app, &ctx)["workspaceStorageError"].is_string());
        app.set_workspace("Minimal");
        app.ui.focused = PanelKind::Project;
        effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name":"Must not overwrite"})).unwrap();
        eframe::App::on_exit(&mut app);
        assert_eq!(std::fs::read(&path).unwrap(), bytes);
        assert!(effectcraft_ui_egui::control::inspect(&app, &ctx)["workspaceStorageError"].is_string());
        std::fs::remove_dir_all(dir).unwrap();
    }
}

#[test]
fn legacy_named_workspaces_migrate_once_and_survive_actual_app_restart() {
    let store = Arc::new(MemoryConfig::default());
    let saved = effectcraft_ui_egui::dock::workspace("Minimal");
    store.write("workspaces.json", &json!({"workspaces":{"Legacy":saved},"floating":{}}).to_string()).unwrap();
    let mut app = EffectcraftApp::new(Session { config: Some(store.clone()), ..Default::default() });
    assert_eq!(app.ui.saved_workspaces.get("Legacy"), Some(&saved));
    app.set_workspace("Legacy");
    let ctx = egui::Context::default();
    effectcraft_ui_egui::menus::invoke(&mut app, &ctx, "window.saveWorkspaceAs", json!({"name":"Migrated"})).unwrap();
    let text = store.read("workspaces.json").unwrap();
    assert_eq!(serde_json::from_str::<serde_json::Value>(&text).unwrap()["version"], 1);
    let restarted = EffectcraftApp::new(Session { config: Some(store), ..Default::default() });
    assert_eq!(restarted.ui.saved_workspaces.get("Legacy"), Some(&saved));
    assert_eq!(restarted.ui.saved_workspaces.get("Migrated"), Some(&saved));
    assert_eq!(restarted.ui.workspace, "Migrated");
}

#[test]
fn tab_and_shift_tab_traverse_toolbar_and_space_activates_only_focused_tool() {
    let mut session = Session::default();
    session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();
    session.execute("layer.newSolid", json!({"name": "Keep unchanged", "color": "#ff0000"})).unwrap();
    let project = session.project.clone();
    let mut app = EffectcraftApp::new(session);
    app.ui.start_screen = false;
    app.ui.show_menu_bar = false;
    let mut h = Harness::builder().with_size(vec2(1400.0, 900.0)).build_eframe(move |_| app);
    h.run_steps(3);
    for _ in 0..8 {
        key(&mut h, Key::Tab, Modifiers::NONE);
        if h.ctx.memory(|m| m.focused()) == Some(Id::new(("tool-slot", 0usize))) {
            break;
        }
    }
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 0usize))));
    key(&mut h, Key::Tab, Modifiers::NONE);
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 1usize))));
    assert_eq!(h.state().ui.tool, Tool::Selection, "focus movement alone must not select a tool");
    key(&mut h, Key::Tab, Modifiers::NONE);
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 2usize))));
    key(&mut h, Key::Tab, Modifiers::SHIFT);
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tool-slot", 1usize))));
    key(&mut h, Key::Space, Modifiers::NONE);
    assert_eq!(h.state().ui.tool, Tool::Hand);
    assert!(!h.state().playback.playing, "Space activates the focused widget, not preview playback");
    assert!(Arc::ptr_eq(&h.state().session.project, &project), "keyboard focus and tool selection do not modify the project");
    let response = h.ctx.read_response(Id::new(("tool-slot", 1usize))).unwrap();
    assert!(
        h.output().shapes.iter().any(|shape| {
            matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(1.0) && r.stroke.color == h.state().tokens.text && r.stroke.width > 0.0)
        }),
        "the custom-painted toolbar must visibly identify keyboard focus"
    );
    let inspected = effectcraft_ui_egui::control::inspect(h.state(), &h.ctx);
    assert_eq!(inspected["keyboardFocus"]["automationId"], "tools.Hand");
    assert_eq!(inspected["keyboardFocus"]["rect"], json!([response.rect.min.x, response.rect.min.y, response.rect.width(), response.rect.height()]));
}

#[test]
fn tab_traversal_activates_an_inactive_dock_tab_without_editing_the_project() {
    let mut session = Session::default();
    session.execute("comp.new", json!({"width": 160, "height": 90, "duration": 1})).unwrap();
    session.execute("layer.newSolid", json!({"name": "Keep unchanged", "color": "#ff0000"})).unwrap();
    let project = session.project.clone();
    let mut app = EffectcraftApp::new(session);
    app.ui.start_screen = false;
    app.ui.show_menu_bar = false;
    // Leave the inactive, layer-named tab visible instead of behind the overflow control.
    if let DockNode::Split { a, .. } = &mut app.ui.dock
        && let DockNode::Split { a, .. } = a.as_mut()
        && let DockNode::Split { size, .. } = a.as_mut()
    {
        *size = SplitSize::FixedA(420.0);
    }
    let mut h = Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app);
    h.run_steps(3);
    assert!(h.state().auto.find("panel.tab.EffectControls").is_some(), "the inactive tab must be visible in this fixture");
    let before = h.state().ui.dock.clone();
    let target = Id::new(("tab", "aaa".to_string(), 1usize));
    let mut tabs = 0;
    for _ in 0..80 {
        key(&mut h, Key::Tab, Modifiers::NONE);
        tabs += 1;
        if h.ctx.memory(|m| m.focused()) == Some(target) {
            break;
        }
    }
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(target));
    println!("Tab presses from no focus to Effect Controls: {tabs}");
    assert_eq!(h.state().ui.dock, before, "traversal alone must not activate a tab");
    key(&mut h, Key::Space, Modifiers::NONE);
    let mut activated = before;
    assert!(activated.activate(PanelKind::EffectControls));
    assert_eq!(h.state().ui.dock, activated);
    assert_eq!(h.state().ui.focused, PanelKind::EffectControls);
    assert!(!h.state().playback.playing);
    assert!(Arc::ptr_eq(&h.state().session.project, &project));
    let response = h.ctx.read_response(target).unwrap();
    assert!(
        h.output().shapes.iter().any(|shape| {
            matches!(&shape.shape, egui::Shape::Rect(r) if r.rect == response.rect.shrink(1.0) && r.stroke.color == h.state().tokens.text && r.stroke.width > 0.0)
        }),
        "the active dock tab must visibly retain keyboard focus"
    );
    let inspected = effectcraft_ui_egui::control::inspect(h.state(), &h.ctx);
    assert_eq!(inspected["keyboardFocus"]["automationId"], "panel.tab.EffectControls");
    key(&mut h, Key::Tab, Modifiers::SHIFT);
    assert_eq!(h.ctx.memory(|m| m.focused()), Some(Id::new(("tab", "aaa".to_string(), 0usize))));
    key(&mut h, Key::Enter, Modifiers::NONE);
    assert_eq!(h.state().ui.focused, PanelKind::Project);
    assert!(!h.state().playback.playing);
    assert!(Arc::ptr_eq(&h.state().session.project, &project));
}

struct ControlDriver {
    h: Harness<'static, EffectcraftApp>,
    tx: std::sync::mpsc::Sender<effectcraft_ui_egui::ControlRequest>,
}

impl ControlDriver {
    fn new() -> Self {
        let (tx, rx) = std::sync::mpsc::channel();
        let mut app = EffectcraftApp::new(Session::default()).with_control(rx);
        app.ui.start_screen = false;
        app.ui.show_menu_bar = false;
        let mut driver = Self { h: Harness::builder().with_size(vec2(1200.0, 760.0)).build_eframe(move |_| app), tx };
        driver.frames(4, true);
        driver.ok("engine.execute", json!({"command":"comp.new", "params":{"name":"Native Validation", "width":160,"height":90,"duration":1}}), true);
        driver.ok("engine.execute", json!({"command":"layer.newSolid", "params":{"name":"Validation Red","color":"#ff0000"}}), true);
        driver.ok("ui.set", json!({"focused":"Timeline"}), true);
        driver.ok("ui.key", json!({"key":"Z","command":true}), true);
        driver.ok("ui.key", json!({"key":"Z","command":true,"shift":true}), true);
        driver
    }

    fn frames(&mut self, count: usize, native_focused: bool) {
        for _ in 0..count {
            let ctx = self.h.ctx.clone();
            let mut raw = std::mem::take(self.h.input_mut());
            raw.focused = native_focused;
            if let Some(viewport) = raw.viewports.get_mut(&egui::ViewportId::ROOT) {
                viewport.focused = Some(native_focused);
            }
            eframe::App::raw_input_hook(self.h.state_mut(), &ctx, &mut raw);
            *self.h.input_mut() = raw;
            self.h.step();
        }
    }

    fn ok(&mut self, method: &str, params: serde_json::Value, native_focused: bool) -> serde_json::Value {
        let (request, reply) = effectcraft_ui_egui::ControlRequest::new(method, params);
        self.tx.send(request).unwrap();
        for _ in 0..60 {
            self.frames(1, native_focused);
            if let Ok(result) = reply.try_recv() {
                assert_eq!(result["ok"], true, "{result}");
                self.frames(2, native_focused);
                return result["result"].clone();
            }
        }
        panic!("no control reply to {method}");
    }
}

#[test]
fn control_root_divider_drag_after_toolbar_and_dock_tab_keyboard_activation() {
    let mut d = ControlDriver::new();
    let project = d.h.state().session.project.clone();
    let times = d.h.state().session.state.times.clone();
    assert_eq!(d.h.state().ui.focused, PanelKind::Timeline);
    assert!(d.h.state().ui.mini_flowchart.is_none());
    d.ok("ui.click", json!({"id":"tools.Selection"}), true);
    for _ in 0..5 {
        d.ok("ui.key", json!({"key":"Tab"}), true);
        assert!(d.h.state().ui.mini_flowchart.is_none(), "Tab entering or traversing widgets must not also invoke the Timeline mini-flowchart shortcut");
    }
    d.ok("ui.key", json!({"key":"Tab","shift":true}), true);
    d.ok("ui.key", json!({"key":"Space"}), true);
    assert_eq!(d.h.state().ui.tool, Tool::Hand);
    d.ok("ui.key", json!({"key":"Tab","shift":true}), true);
    d.ok("ui.key", json!({"key":"Enter"}), true);
    assert_eq!(d.h.state().ui.tool, Tool::Selection);
    d.ok("ui.drag", json!({"from":{"id":"dock.gutter.aa","fx":0.5,"fy":0.5},"to":{"id":"dock.gutter.aa","fx":10.5,"fy":0.5},"steps":8}), true);
    d.ok("ui.click", json!({"id":"tools.Selection"}), true);
    // The toolbar can grow as upstream adds controls. Traverse to the actual response
    // identity rather than assuming a fixed number of focus stops.
    let target = Id::new(("tab", "aaa".to_string(), 1usize));
    for tabs in 1..=100 {
        d.ok("ui.key", json!({"key":"Tab"}), true);
        assert!(d.h.state().ui.mini_flowchart.is_none(), "dock-tab traversal must not open a foreground popup");
        if d.h.ctx.memory(|memory| memory.focused()) == Some(target) {
            println!("control Tab presses to Effect Controls: {tabs}");
            break;
        }
    }
    assert_eq!(d.h.ctx.memory(|memory| memory.focused()), Some(target), "Effect Controls must remain reachable by control-channel Tab traversal");
    d.ok("ui.key", json!({"key":"Space"}), true);
    assert_eq!(d.h.state().ui.focused, PanelKind::EffectControls);
    d.ok("ui.key", json!({"key":"Tab","shift":true}), true);
    d.ok("ui.key", json!({"key":"Enter"}), true);
    assert_eq!(d.h.state().ui.focused, PanelKind::Project);
    let before = d.h.state().ui.dock.clone();
    let gutter = d.h.state().auto.find("dock.gutter.").unwrap().rect;
    println!("root gutter before control drag: {gutter:?}; mini-flowchart: {:?}", d.h.state().ui.mini_flowchart);
    d.ok("ui.drag", json!({"from":{"id":"dock.gutter.","fx":0.5,"fy":0.5},"to":{"id":"dock.gutter.","fx":5.0,"fy":0.5},"steps":8}), true);
    assert_ne!(d.h.state().ui.dock, before, "the foreground root divider must still accept a drag after dock-tab keyboard activation");
    assert_eq!(d.h.state().session.state.times, times);
    assert!(Arc::ptr_eq(&d.h.state().session.project, &project));
    assert!(!d.h.state().playback.playing);
    for _ in 0..160 {
        d.ok("ui.key", json!({"key":"Tab"}), true);
        assert!(d.h.state().ui.mini_flowchart.is_none(), "wrapping widget traversal must not dispatch the application Tab binding");
    }
}

#[test]
fn unowned_tab_keeps_the_timeline_mini_flowchart_shortcut() {
    let mut session = Session::default();
    session.execute("comp.new", json!({"width":160,"height":90,"duration":1})).unwrap();
    let mut app = EffectcraftApp::new(session);
    app.ui.focused = PanelKind::Timeline;
    let ctx = egui::Context::default();
    let raw = egui::RawInput {
        events: vec![egui::Event::Key { key: Key::Tab, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE }],
        ..Default::default()
    };
    let mut output = ctx.run_ui(raw, |ui| {
        let ctx = ui.ctx();
        effectcraft_ui_egui::menus::handle_shortcuts(&mut app, ctx);
        assert!(app.ui.mini_flowchart.is_none(), "application Tab waits until widgets can claim focus");
        assert!(!ctx.egui_wants_keyboard_input());
        effectcraft_ui_egui::menus::handle_tab_shortcut(&mut app, ctx);
    });
    output.textures_delta.clear();
    assert!(app.ui.mini_flowchart.is_some(), "an unowned Tab still invokes the application binding");
}