#![cfg(feature = "desktop")]

use notesagent_host::{
    records, sync_client::SyncClient, sync_scope::OptionalScope, workspace::Workspace,
};
use serde_json::{json, Value};
use std::{
    io::{BufRead, BufReader},
    path::Path,
    process::{Child, Command, Stdio},
    sync::{Arc, Mutex},
};
use zeroize::Zeroizing;

struct Server(Child);

impl Drop for Server {
    fn drop(&mut self) {
        self.0.stdin.take();
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}

fn record(kind: &str, id: &str, data: Value) -> Value {
    json!({"schema":1,"kind":kind,"id":id,"data":data})
}

fn records_fixture() -> Vec<(&'static str, &'static str, Value, bool)> {
    let task = "task_00000000000000000000000000000001";
    let skill = "user_skill_00000000000000000000000000000001";
    let conversation = "conversation_00000000000000000000000000000001";
    let run = "agent_run_00000000000000000000000000000001";
    let provider = "provider_00000000000000000000000000000001";
    let extension = "extension_00000000000000000000000000000001";
    vec![
        (
            "task",
            task,
            record(
                "task",
                task,
                json!({"title":"Ship","description":"Production checklist","status":"todo","note_id":null,"due_at_ms":null,"created_at_ms":1,"updated_at_ms":2}),
            ),
            false,
        ),
        (
            "user_skill",
            skill,
            record(
                "user_skill",
                skill,
                json!({"version":1,"name":"Review","description":"Review a note","prompt":"Check carefully","tools":["notes.read"],"permissions":["notes.read"],"retrieval":{"top_k":10,"rerank":true,"citation":true},"required_capabilities":["chat"],"created_at_ms":1,"updated_at_ms":2}),
            ),
            false,
        ),
        (
            "theme_settings",
            "appearance",
            record(
                "theme_settings",
                "appearance",
                json!({"themeId":"dark","fontEditorSize":18,"fontEditorFamily":"system-ui","lineHeight":1.7,"codeBlockTheme":"auto","headings":{"custom":false,"family":"inherit","levels":([32,28,24,21,18,16].map(|size|json!({"size":size,"weight":700})))}}),
            ),
            false,
        ),
        (
            "preferences",
            "editor",
            record(
                "preferences",
                "editor",
                json!({"restoreLastVault":true,"autoSaveInterval":1500,"language":"zh-CN","defaultEditorMode":"wysiwyg","editorLineWidth":80,"spellCheck":false,"markdown":{"heading":"atx","bullet":"-","incrementList":true,"fence":"`","math":true,"callouts":true,"diagrams":true,"autoLinks":true,"lineNumbers":true,"wrapCode":false,"indent":4,"defaultLanguage":""},"presets":[]}),
            ),
            false,
        ),
        (
            "persona",
            "default",
            record(
                "persona",
                "default",
                json!({"version":1,"name":"Writer","system_prompt":"Be concise","dialogue_pairs":[]}),
            ),
            true,
        ),
        (
            "layout",
            "sidebars",
            record(
                "layout",
                "sidebars",
                json!({"primaryExpanded":true,"workspaceWidth":400,"chatWidth":320}),
            ),
            true,
        ),
        (
            "conversation",
            conversation,
            record(
                "conversation",
                conversation,
                json!({"title":"Release review","active_leaf":"message_1","created_at_ms":1,"updated_at_ms":2,"messages":[{"message_id":"message_1","parent_message_id":null,"role":"user","content":"Review the release","thinking":null,"attachments":[],"created_at_ms":1}]}),
            ),
            true,
        ),
        (
            "agent_history",
            run,
            record(
                "agent_history",
                run,
                json!({"status":"completed","input":"Review release","output":"Ready","model":"gpt-5.6","skill_id":null,"error_code":null,"error_message":null,"token_usage":42,"created_at_ms":1,"updated_at_ms":2}),
            ),
            true,
        ),
        (
            "provider_settings",
            provider,
            record(
                "provider_settings",
                provider,
                json!({"version":1,"provider_type":"openai_responses","name":"OpenAI","base_url":"https://api.openai.com/v1","default_model":"gpt-5.6","enabled":true,"capabilities":["chat","tool_calling"]}),
            ),
            true,
        ),
        (
            "extension_installation",
            extension,
            record(
                "extension_installation",
                extension,
                json!({"package_kind":"plugin","package_id":"opennexus.review","source":"community/opennexus.review","version":"1.2.3","sha256":"a".repeat(64)}),
            ),
            true,
        ),
    ]
}

fn seed(workspace: &mut Workspace) -> Vec<(String, Value, bool)> {
    workspace
        .write("notes/default.md", "", b"# Default markdown", "local")
        .unwrap();
    workspace
        .write(
            "attachments/manual.pdf",
            "",
            b"portable attachment",
            "local",
        )
        .unwrap();
    let mut written = Vec::new();
    for (kind, id, value, optional) in records_fixture() {
        let path = records::path_for(kind, id).unwrap();
        workspace
            .write(&path, "", &serde_json::to_vec(&value).unwrap(), "local")
            .unwrap();
        written.push((path, value, optional));
    }
    for (path, contents) in [
        ("logs/trace.md", "forbidden log"),
        ("cache/search.md", "forbidden cache"),
        ("models/local.md", "forbidden model"),
        ("index.sqlite3", "forbidden index"),
        ("vectors.bin", "forbidden vectors"),
        ("provider-settings.json", "fixture-api-key"),
    ] {
        workspace
            .write(path, "", contents.as_bytes(), "local")
            .unwrap();
    }
    written
}

async fn push_all(
    client: &SyncClient,
    workspace: &Arc<Mutex<Workspace>>,
    binding: &notesagent_host::sync_state::Binding,
) {
    while client.push_one(workspace, binding).await.unwrap() {}
}

async fn pull_all(
    client: &SyncClient,
    workspace: &Arc<Mutex<Workspace>>,
    binding: &notesagent_host::sync_state::Binding,
) {
    while client.pull_page(workspace, binding).await.unwrap() > 0 {}
}

async fn create_remote(client: &SyncClient, name: &str) -> String {
    client
        .json(
            reqwest::Method::POST,
            "sync/v1/vaults",
            Some(json!({"name":name})),
        )
        .await
        .unwrap()["vault_id"]
        .as_str()
        .unwrap()
        .to_owned()
}

#[tokio::test]
async fn s08_actual_service_enforces_classification_and_roundtrips_selected_records() {
    let service_root = tempfile::tempdir().unwrap();
    std::fs::write(service_root.path().join(".opennexus-test"), b"fixture").unwrap();
    let service = Path::new(env!("CARGO_MANIFEST_DIR"))
        .join("../../server sync")
        .canonicalize()
        .unwrap();
    let python = service.join(if cfg!(windows) {
        ".venv/Scripts/python.exe"
    } else {
        ".venv/bin/python"
    });
    let mut server = Server(
        Command::new(python)
            .args(["-m", "tests.host_fixture"])
            .arg(service_root.path())
            .current_dir(service)
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::null())
            .spawn()
            .unwrap(),
    );
    let mut line = String::new();
    BufReader::new(server.0.stdout.take().unwrap())
        .read_line(&mut line)
        .unwrap();
    let ready: Value = serde_json::from_str(&line).unwrap();
    let endpoint = format!("http://127.0.0.1:{}", ready["port"]);
    let public = SyncClient::new(&endpoint, Zeroizing::new(String::new()), true).unwrap();
    public.handshake().await.unwrap();
    let session = public
        .login(
            "rust-fixture",
            Zeroizing::new("controlled-fixture-password".into()),
            "S-08 classification",
        )
        .await
        .unwrap();
    let client = SyncClient::new(
        &endpoint,
        Zeroizing::new(session.access_token.clone()),
        true,
    )
    .unwrap();

    let default_remote = create_remote(&client, "S-08 default").await;
    let source_root = tempfile::tempdir().unwrap();
    let mut source = Workspace::open(source_root.path()).unwrap();
    let written = seed(&mut source);
    let source = Arc::new(Mutex::new(source));
    let source_binding = source
        .lock()
        .unwrap()
        .sync_bind_empty(&endpoint, &default_remote, "rust-fixture")
        .unwrap();
    push_all(&client, &source, &source_binding).await;
    let default_snapshot = client.snapshot(&default_remote).await.unwrap();
    let default_paths = default_snapshot
        .items
        .iter()
        .map(|item| item.path.as_str())
        .collect::<Vec<_>>();
    assert_eq!(default_paths.len(), 6);
    assert!(default_paths.contains(&"notes/default.md"));
    assert!(default_paths.contains(&"attachments/manual.pdf"));
    assert!(written
        .iter()
        .filter(|(_, _, optional)| !optional)
        .all(|(path, _, _)| default_paths.contains(&path.as_str())));
    assert!(written
        .iter()
        .filter(|(_, _, optional)| *optional)
        .all(|(path, _, _)| !default_paths.contains(&path.as_str())));
    assert!(default_paths.iter().all(|path| {
        !path.starts_with("logs/")
            && !path.starts_with("cache/")
            && !path.starts_with("models/")
            && !path.contains("index")
            && !path.contains("vectors")
            && !path.contains("provider-settings.json")
    }));

    let target_root = tempfile::tempdir().unwrap();
    let target = Arc::new(Mutex::new(Workspace::open(target_root.path()).unwrap()));
    let target_binding = target
        .lock()
        .unwrap()
        .sync_bind_download(&endpoint, &default_remote, "rust-fixture")
        .unwrap();
    pull_all(&client, &target, &target_binding).await;
    assert_eq!(
        target
            .lock()
            .unwrap()
            .read("notes/default.md")
            .unwrap()
            .content,
        "# Default markdown"
    );
    assert_eq!(
        target
            .lock()
            .unwrap()
            .read("attachments/manual.pdf")
            .unwrap()
            .content,
        "portable attachment"
    );
    for (path, value, optional) in &written {
        if *optional {
            assert!(!target_root.path().join(path).exists());
        } else {
            assert_eq!(
                serde_json::from_slice::<Value>(
                    &std::fs::read(target_root.path().join(path)).unwrap()
                )
                .unwrap(),
                *value
            );
        }
    }

    let optional_remote = create_remote(&client, "S-08 optional").await;
    let optional_source_root = tempfile::tempdir().unwrap();
    let mut optional_source = Workspace::open(optional_source_root.path()).unwrap();
    optional_source
        .sync_set_optional_scope(OptionalScope {
            persona: true,
            layout: true,
            conversations: true,
            agent_history: true,
            provider_settings: true,
            extension_installations: true,
        })
        .unwrap();
    let optional_written = seed(&mut optional_source);
    let optional_source = Arc::new(Mutex::new(optional_source));
    let optional_source_binding = optional_source
        .lock()
        .unwrap()
        .sync_bind_empty(&endpoint, &optional_remote, "rust-fixture")
        .unwrap();
    push_all(&client, &optional_source, &optional_source_binding).await;
    assert_eq!(
        client.snapshot(&optional_remote).await.unwrap().items.len(),
        12
    );

    let optional_target_root = tempfile::tempdir().unwrap();
    let mut optional_target = Workspace::open(optional_target_root.path()).unwrap();
    optional_target
        .sync_set_optional_scope(OptionalScope {
            persona: true,
            layout: true,
            conversations: true,
            agent_history: true,
            provider_settings: true,
            extension_installations: true,
        })
        .unwrap();
    let optional_target = Arc::new(Mutex::new(optional_target));
    let optional_target_binding = optional_target
        .lock()
        .unwrap()
        .sync_bind_download(&endpoint, &optional_remote, "rust-fixture")
        .unwrap();
    pull_all(&client, &optional_target, &optional_target_binding).await;
    for (path, value, _) in &optional_written {
        assert_eq!(
            serde_json::from_slice::<Value>(
                &std::fs::read(optional_target_root.path().join(path)).unwrap()
            )
            .unwrap(),
            *value
        );
    }
    let installation = &optional_written
        .iter()
        .find(|(_, value, _)| value["kind"] == "extension_installation")
        .unwrap()
        .1["data"];
    let keys = installation
        .as_object()
        .unwrap()
        .keys()
        .cloned()
        .collect::<Vec<_>>();
    assert_eq!(keys.len(), 5);
    assert!(keys.iter().all(|key| {
        matches!(
            key.as_str(),
            "package_kind" | "package_id" | "source" | "version" | "sha256"
        )
    }));
}