use serde_json::{json, Value};
use std::io::{BufRead, BufReader, Read, Write};
use std::process::{Command, Stdio};

fn send_message(stdin: &mut std::process::ChildStdin, msg: Value) {
    let s = serde_json::to_string(&msg).unwrap();
    let payload = format!("Content-Length: {}\r\n\r\n{}", s.len(), s);
    stdin.write_all(payload.as_bytes()).unwrap();
    stdin.flush().unwrap();
}

fn read_message(stdout: &mut std::process::ChildStdout) -> Option<Value> {
    let mut reader = BufReader::new(stdout);
    let mut length = 0;
    
    // Read headers
    loop {
        let mut line = String::new();
        if reader.read_line(&mut line).unwrap_or(0) == 0 {
            return None; // EOF
        }
        let line = line.trim_end();
        if line.is_empty() {
            break;
        }
        if let Some(len_str) = line.strip_prefix("Content-Length: ") {
            length = len_str.parse().unwrap_or(0);
        }
    }
    
    if length == 0 {
        return None;
    }
    
    // Read body
    let mut buf = vec![0u8; length];
    reader.read_exact(&mut buf).unwrap();
    let body_str = String::from_utf8_lossy(&buf);
    
    Some(serde_json::from_str(&body_str).unwrap())
}

#[test]
#[cfg(unix)]
fn test_mcp_initialization_and_tools_list() {
    let mut nvim_exe = std::env::current_exe().unwrap();
    nvim_exe.pop();
    nvim_exe.pop();
    nvim_exe.push(format!("mcp-memory-linux-nvim{}", std::env::consts::EXE_SUFFIX));

    let mut child = Command::new(&nvim_exe)
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("Failed to start mcp-memory-linux-nvim");

    let mut stdin = child.stdin.take().expect("Failed to open stdin");
    let mut stdout = child.stdout.take().expect("Failed to open stdout");

    // 0. Test server/discover (probe)
    let discover_req = json!({
        "jsonrpc": "2.0",
        "method": "server/discover",
        "params": {},
        "id": 0
    });
    send_message(&mut stdin, discover_req);
    let discover_resp = read_message(&mut stdout).expect("Failed to read server/discover response");
    assert_eq!(discover_resp["error"]["code"], -32601);

    // 1. Test Initialize
    let init_req = json!({
        "jsonrpc": "2.0",
        "method": "initialize",
        "params": {
            "protocolVersion": "2024-11-05",
            "capabilities": {},
            "clientInfo": {
                "name": "test-client",
                "version": "1.0"
            }
        },
        "id": 1
    });

    // Send initialize using JSONL format!
    let s = serde_json::to_string(&init_req).unwrap();
    stdin.write_all(format!("{}\n", s).as_bytes()).unwrap();
    stdin.flush().unwrap();
    
    let init_resp = read_message(&mut stdout).expect("Failed to read initialize response");
    
    assert_eq!(init_resp["jsonrpc"], "2.0");
    assert_eq!(init_resp["id"], 1);
    
    // Verify capabilities
    let capabilities = &init_resp["result"]["capabilities"];
    assert_eq!(capabilities["tools"], serde_json::json!({}));

    // 2. Test tools/list
    let tools_req = json!({
        "jsonrpc": "2.0",
        "method": "tools/list",
        "params": {},
        "id": 2
    });
    
    send_message(&mut stdin, tools_req);
    
    let tools_resp = read_message(&mut stdout).expect("Failed to read tools/list response");
    
    assert_eq!(tools_resp["jsonrpc"], "2.0");
    assert_eq!(tools_resp["id"], 2);
    
    let tools = tools_resp["result"]["tools"].as_array().expect("result.tools must be an array");
    assert!(!tools.is_empty(), "Server must expose at least one tool");
    
    let has_get_active_buffer = tools.iter().any(|t| t["name"] == "nvim_get_active_buffer");
    assert!(has_get_active_buffer, "Missing nvim_get_active_buffer tool");

    child.kill().expect("Failed to kill child");
    child.wait().expect("Failed to wait on child");
}