use std::error::Error;

use ely_browser_core::{BrowserCore, InitialBrowserConfig};
use ely_domain::{
    SyncConnectionState, SyncObjectKind, SyncObjectPolicy, SyncObjectState, SyncObjectStatus,
    UrlText,
};

#[test]
fn default_sync_status_reflects_local_browser_state() -> Result<(), Box<dyn Error>> {
    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    core.create_space("Research", "R", 0xf54e00)?;
    core.open_tab(UrlText::parse("https://example.com/research")?);
    core.bookmark_active_tab()?;
    core.save_active_url_note("sync note")?;
    core.save_active_tab_to_reading_list()?;

    let snapshot = core.snapshot()?;
    let status = &snapshot.sync_status;

    assert_eq!(status.connection(), &SyncConnectionState::SignedOut);
    assert_eq!(status.pending_objects(), 0);
    assert_eq!(status.failed_objects(), 0);
    assert_eq!(
        status.objects(),
        &[
            SyncObjectStatus::new(SyncObjectKind::Spaces, 2, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::Tabs, 3, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::Bookmarks, 1, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::Notes, 1, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::ReadingList, 1, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::Profiles, 1, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::SitePermissions, 0, SyncObjectState::LocalOnly),
            SyncObjectStatus::new(SyncObjectKind::History, 1, SyncObjectState::PrivacyControlled),
            SyncObjectStatus::new(SyncObjectKind::PluginSettings, 0, SyncObjectState::LocalOnly),
        ],
    );
    Ok(())
}

#[test]
fn sync_object_policy_pauses_object_kind() -> Result<(), Box<dyn Error>> {
    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    core.set_sync_object_policy(SyncObjectKind::Tabs, SyncObjectPolicy::Paused);

    let snapshot = core.snapshot()?;
    let Some(tabs_status) =
        snapshot.sync_status.objects().iter().find(|status| status.kind() == SyncObjectKind::Tabs)
    else {
        return Err("missing tabs sync status".into());
    };
    let Some(spaces_status) = snapshot
        .sync_status
        .objects()
        .iter()
        .find(|status| status.kind() == SyncObjectKind::Spaces)
    else {
        return Err("missing spaces sync status".into());
    };

    assert_eq!(core.sync_object_policy(SyncObjectKind::Tabs), SyncObjectPolicy::Paused);
    assert_eq!(tabs_status.policy(), SyncObjectPolicy::Paused);
    assert_eq!(tabs_status.state(), SyncObjectState::Paused);
    assert_eq!(spaces_status.policy(), SyncObjectPolicy::Enabled);
    assert_eq!(spaces_status.state(), SyncObjectState::LocalOnly);
    Ok(())
}

#[test]
fn tab_sync_status_counts_sync_enabled_tabs() -> Result<(), Box<dyn Error>> {
    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    let unsynced_tab_id = core.open_tab(UrlText::parse("https://example.com/local-only")?);

    core.set_tab_sync_enabled(&unsynced_tab_id, false)?;
    let snapshot = core.snapshot()?;
    let Some(tabs_status) =
        snapshot.sync_status.objects().iter().find(|status| status.kind() == SyncObjectKind::Tabs)
    else {
        return Err("missing tabs sync status".into());
    };
    let Some(unsynced_tab) = snapshot.tabs.iter().find(|tab| tab.id() == &unsynced_tab_id) else {
        return Err("missing unsynced tab".into());
    };

    assert!(!unsynced_tab.sync_enabled());
    assert_eq!(tabs_status.local_count(), 1);
    Ok(())
}

#[test]
fn sync_snapshot_imports_remote_bookmarks_into_active_scope() -> Result<(), Box<dyn Error>> {
    let mut source = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    source.open_tab(UrlText::parse("https://example.com/research")?);
    let bookmark_id = source.bookmark_active_tab()?;
    source.set_bookmark_collection_name(&bookmark_id, "Research")?;
    source.set_bookmark_tags(&bookmark_id, vec!["rust".to_string(), "gpui".to_string()])?;
    source.set_bookmark_note(&bookmark_id, "Read later")?;
    let bytes = source.build_sync_snapshot_bytes()?;

    let mut target = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    let target_profile_id = target.snapshot()?.active_profile_id;
    let target_space_id = target.snapshot()?.active_space_id;
    let summary = target.apply_sync_snapshot_bytes(&bytes)?;
    let snapshot = target.snapshot()?;

    assert_eq!(summary.imported(), 1);
    assert_eq!(summary.updated(), 0);
    assert_eq!(summary.skipped(), 0);
    assert_eq!(snapshot.bookmarks.len(), 1);
    assert_eq!(snapshot.bookmarks[0].profile_id(), &target_profile_id);
    assert_eq!(snapshot.bookmarks[0].space_id(), &target_space_id);
    assert_eq!(snapshot.bookmarks[0].collection_name(), "Research");
    assert_eq!(snapshot.bookmarks[0].tags(), &["rust".to_string(), "gpui".to_string()]);
    assert_eq!(snapshot.bookmarks[0].note(), Some("Read later"));
    Ok(())
}

#[test]
fn sync_snapshot_updates_existing_bookmark_metadata() -> Result<(), Box<dyn Error>> {
    let mut source = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    source.open_tab(UrlText::parse("https://example.com/research")?);
    let source_bookmark_id = source.bookmark_active_tab()?;
    source.set_bookmark_collection_name(&source_bookmark_id, "Research")?;
    source.set_bookmark_tags(&source_bookmark_id, vec!["servo".to_string()])?;
    source.set_bookmark_note(&source_bookmark_id, "Canonical")?;
    let bytes = source.build_sync_snapshot_bytes()?;

    let mut target = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    target.open_tab(UrlText::parse("https://example.com/research")?);
    let target_bookmark_id = target.bookmark_active_tab()?;
    target.set_bookmark_collection_name(&target_bookmark_id, "Inbox")?;
    let summary = target.apply_sync_snapshot_bytes(&bytes)?;
    let snapshot = target.snapshot()?;

    assert_eq!(summary.imported(), 0);
    assert_eq!(summary.updated(), 1);
    assert_eq!(summary.skipped(), 0);
    assert_eq!(snapshot.bookmarks.len(), 1);
    assert_eq!(snapshot.bookmarks[0].id(), &target_bookmark_id);
    assert_eq!(snapshot.bookmarks[0].collection_name(), "Research");
    assert_eq!(snapshot.bookmarks[0].tags(), &["servo".to_string()]);
    assert_eq!(snapshot.bookmarks[0].note(), Some("Canonical"));
    Ok(())
}

#[test]
fn sync_snapshot_rejects_unknown_schema_rev() -> Result<(), Box<dyn Error>> {
    let mut core = BrowserCore::new(InitialBrowserConfig::ely_defaults()?)?;
    let bytes = br#"{"schema_rev":999,"bookmarks":[]}"#;

    let Err(error) = core.apply_sync_snapshot_bytes(bytes) else {
        return Err("expected sync snapshot schema error".into());
    };

    assert!(error.to_string().contains("unsupported schema_rev 999"));
    Ok(())
}