extern crate alloc;

use tui_orchestrator::focus::{FocusError, FocusId, FocusManager, Focusable};

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[allow(dead_code)]
enum TestId {
    Field(usize),
    Button(&'static str),
    Menu,
    Dialog,
}

impl FocusId for TestId {}

#[test]
fn test_focus_id_trait() {
    let id1 = TestId::Button("save");
    let id2 = TestId::Button("save");
    assert_eq!(id1, id2);
}

#[test]
fn test_manager_new() {
    let manager: FocusManager<TestId> = FocusManager::new();
    assert!(manager.is_empty());
    assert_eq!(manager.current(), None);
}

#[test]
fn test_manager_set_targets() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    assert_eq!(manager.len(), 3);
    assert_eq!(manager.current(), Some(&TestId::Field(0)));
}

#[test]
fn test_manager_navigation() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    assert_eq!(manager.current(), Some(&TestId::Field(0)));

    manager.next();
    assert_eq!(manager.current(), Some(&TestId::Field(1)));

    manager.next();
    assert_eq!(manager.current(), Some(&TestId::Button("save")));

    manager.next();
    assert_eq!(manager.current(), Some(&TestId::Button("save")));

    manager.prev();
    assert_eq!(manager.current(), Some(&TestId::Field(1)));

    manager.first();
    assert_eq!(manager.current(), Some(&TestId::Field(0)));

    manager.last();
    assert_eq!(manager.current(), Some(&TestId::Button("save")));
}

#[test]
fn test_manager_prev_at_start() {
    let mut manager: FocusManager<TestId> = FocusManager::new();
    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    manager.prev();
    assert_eq!(manager.current(), Some(&TestId::Field(0)));
}

#[test]
fn test_manager_set_focus() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    let result = manager.set_focus(TestId::Button("save"));
    assert!(result.is_ok());
    assert_eq!(manager.current(), Some(&TestId::Button("save")));

    let result = manager.set_focus(TestId::Field(0));
    assert!(result.is_ok());
    assert_eq!(manager.current(), Some(&TestId::Field(0)));
}

#[test]
fn test_manager_set_focus_not_found() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    let result = manager.set_focus(TestId::Menu);
    assert_eq!(result, Err(FocusError::TargetNotFound));
}

#[test]
fn test_manager_set_focus_empty() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    let result = manager.set_focus(TestId::Menu);
    assert_eq!(result, Err(FocusError::EmptyTargets));
}

#[test]
fn test_manager_overlay() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    manager.set_overlay(TestId::Menu);
    assert!(manager.has_overlay());
    assert_eq!(manager.current(), Some(&TestId::Menu));

    manager.next();
    assert_eq!(manager.current(), Some(&TestId::Menu));

    manager.clear_overlay();
    assert!(!manager.has_overlay());
    assert_eq!(manager.current(), Some(&TestId::Field(0)));
}

#[test]
fn test_manager_overlay_with_focus() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    manager.set_focus(TestId::Button("save")).unwrap();
    assert_eq!(manager.current(), Some(&TestId::Button("save")));

    manager.set_overlay(TestId::Menu);
    assert_eq!(manager.current(), Some(&TestId::Menu));

    manager.clear_overlay();
    assert_eq!(manager.current(), Some(&TestId::Button("save")));
}

#[test]
fn test_manager_add_remove_target() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.add_target(TestId::Field(0));
    manager.add_target(TestId::Field(1));

    assert_eq!(manager.len(), 2);
    assert_eq!(manager.current(), Some(&TestId::Field(0)));

    manager.remove_target(&TestId::Field(0));
    assert_eq!(manager.len(), 1);
    assert_eq!(manager.current(), Some(&TestId::Field(1)));
}

#[test]
fn test_manager_remove_current_adjusts_index() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![TestId::Field(0), TestId::Field(1), TestId::Field(2)]);

    manager.next();
    assert_eq!(manager.current(), Some(&TestId::Field(1)));

    manager.remove_target(&TestId::Field(1));
    assert_eq!(manager.len(), 2);
    assert_eq!(manager.current(), Some(&TestId::Field(2)));
}

#[test]
fn test_manager_query() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    let query = manager.query();
    assert_eq!(query.current, Some(&TestId::Field(0)));
    assert!(query.is_focused(&TestId::Field(0)));
    assert!(!query.is_focused(&TestId::Field(1)));
    assert!(query.has_focus());
}

#[test]
fn test_manager_query_no_focus() {
    let manager: FocusManager<TestId> = FocusManager::new();

    let query = manager.query();
    assert_eq!(query.current, None);
    assert!(!query.has_focus());
}

#[test]
fn test_manager_is_focused() {
    let mut manager: FocusManager<TestId> = FocusManager::new();

    manager.set_targets(vec![
        TestId::Field(0),
        TestId::Field(1),
        TestId::Button("save"),
    ]);

    assert!(manager.is_focused(&TestId::Field(0)));
    assert!(!manager.is_focused(&TestId::Field(1)));

    manager.next();
    assert!(!manager.is_focused(&TestId::Field(0)));
    assert!(manager.is_focused(&TestId::Field(1)));
}

#[test]
fn test_focusable_trait() {
    struct TestComponent;

    impl Focusable<TestId> for TestComponent {
        fn focus_targets(&self) -> alloc::vec::Vec<TestId> {
            vec![TestId::Field(0), TestId::Field(1), TestId::Button("save")]
        }
    }

    let component = TestComponent;
    let targets = component.focus_targets();
    assert_eq!(targets.len(), 3);
}