//! A new repository's starting files drafted by an assistant (#347): asked

//! for over the API, drafted in the background by the owner's assistant,

//! committed to the empty repository as the person who asked (the hub as

//! their delegate), never over files that are there, and refused plainly

//! when no assistant is set up or the person has not delegated to the hub.

use axum::body::Body;

use axum::http::{header, Request, StatusCode};

use http_body_util::BodyExt;

use oxy_core::repo::{IdentityScope, Repo};

use oxygenhub::config::Config;

use oxygenhub::db;

use oxygenhub::Shared;

use std::path::Path;

use tower::ServiceExt;

fn hermetic() {

    static ONCE: std::sync::Once = std::sync::Once::new();

    static DIR: std::sync::OnceLock<tempfile::TempDir> = std::sync::OnceLock::new();

    ONCE.call_once(|| {

        let d = tempfile::tempdir().unwrap();

        std::env::set_var("OXY_HOME", d.path());

        DIR.set(d).ok();

    });

}

struct Hub {

    app: Shared,

    _dir: tempfile::TempDir,

}

async fn hub() -> Hub {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let mut config = Config::load(dir.path()).unwrap();

    config.registration.setup_code = "test-setup".into();

    config.registration.mode = "open".into();

    // The stand-in model is on this machine.

    config.outbound.allow = vec!["http://127.0.0.1".into()];

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    config.server.base_url = format!("http://127.0.0.1:{port}");

    let app = oxygenhub::build(config).await.unwrap();

    let router = oxygenhub::router(app.clone());

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    Hub { app, _dir: dir }

}

struct Res {

    status: StatusCode,

    body: String,

    cookie: Option<String>,

}

async fn send(app: &Shared, method: &str, path: &str, cookie: Option<&str>, token: Option<&str>, body: Option<(&str, String)>) -> Res {

    let mut req = Request::builder().method(method).uri(path);

    if let Some(c) = cookie {

        req = req.header(header::COOKIE, format!("oxyhub={c}"));

    }

    if let Some(t) = token {

        req = req.header(header::AUTHORIZATION, format!("Bearer {t}"));

    }

    let body = match body {

        Some((ct, b)) => {

            req = req.header(header::CONTENT_TYPE, ct);

            Body::from(b)

        }

        None => Body::empty(),

    };

    let res = oxygenhub::router(app.clone()).oneshot(req.body(body).unwrap()).await.unwrap();

    let status = res.status();

    let cookie = res

        .headers()

        .get(header::SET_COOKIE)

        .and_then(|v| v.to_str().ok())

        .and_then(|v| v.split(';').next())

        .and_then(|kv| kv.split_once('='))

        .map(|(_, v)| v.to_string());

    let bytes = res.into_body().collect().await.unwrap().to_bytes();

    Res { status, body: String::from_utf8_lossy(&bytes).into_owned(), cookie }

}

async fn post(app: &Shared, path: &str, cookie: Option<&str>, form: &str) -> Res {

    send(app, "POST", path, cookie, None, Some(("application/x-www-form-urlencoded", form.to_string()))).await

}

async fn api(app: &Shared, method: &str, path: &str, token: Option<&str>, json: Option<serde_json::Value>) -> Res {

    send(app, method, &format!("/api/v1{path}"), None, token, json.map(|j| ("application/json", j.to_string()))).await

}

async fn register(app: &Shared, user: &str) -> String {

    let r = post(

        app,

        "/register",

        None,

        &format!("username={user}&email={user}%40example.com&password=correct-horse-battery&setup=test-setup"),

    )

    .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    r.cookie.unwrap()

}

/// `user`'s identity, delegating to the hub's key and linked to the

/// account, as web edits need; the client checkout that holds it.

async fn delegate(app: &Shared, user: &str, work: &Path) -> Repo {

    let id = db::accounts::account_by_name(&app.db, user).await.unwrap().unwrap().id;

    let mut client = Repo::init(work).unwrap();

    client.create_identity(user, &format!("{user}@example.com"), IdentityScope::Repo).unwrap();

    client.delegate_add(app.hub_key.identity.clone(), oxy_core::identity::Scope::CHANGES | oxy_core::identity::Scope::REFS, None).unwrap();

    let key = client.config.author_key.unwrap();

    let ident = client.identity(&key).unwrap();

    db::accounts::link_identity(&app.db, id, &key.to_hex(), &ident.name, &ident.email, &ident.encode()).await.unwrap();

    client

}

/// A stand-in model: files for any request, but no files when asked to make-no-files.

async fn model() -> String {

    let router = axum::Router::new().route(

        "/v1/chat/completions",

        axum::routing::post(|axum::Json(req): axum::Json<serde_json::Value>| async move {

            let asked = req.to_string();

            let content = if asked.contains("make-no-files") {

                "Sure! I can help with that.".to_string()

            } else {

                "<<<FILE README.md>>>\n# Pong\n\nA small pong game.\n<<<END>>>\n<<<FILE src/main.rs>>>\nfn main() {}\n<<<END>>>\n"

                    .to_string()

            };

            axum::Json(serde_json::json!({ "choices": [{ "message": { "content": content } }] }))

        }),

    );

    let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();

    let port = listener.local_addr().unwrap().port();

    tokio::spawn(async move { axum::serve(listener, router).await.unwrap() });

    format!("http://127.0.0.1:{port}/v1/chat/completions")

}

async fn admin_token(app: &Shared, user: &str) -> String {

    let me = db::accounts::account_by_name(&app.db, user).await.unwrap().unwrap();

    let (secret, hash) = oxygenhub::auth::new_token();

    db::accounts::create_token(&app.db, me.id, "phone", &hash, "repo:read,repo:write,repo:admin", "", None).await.unwrap();

    secret

}

async fn wait_done(app: &Shared, repo: &str, token: &str) -> serde_json::Value {

    for _ in 0..100 {

        let r = api(app, "GET", &format!("/repos/{repo}/starter"), Some(token), None).await;

        let v: serde_json::Value = serde_json::from_str(&r.body).unwrap();

        if v["status"] != "running" {

            return v;

        }

        tokio::time::sleep(std::time::Duration::from_millis(100)).await;

    }

    panic!("the starter for {repo} is still running");

}

#[tokio::test(flavor = "multi_thread")]

async fn an_assistant_drafts_an_empty_repositorys_starting_files() {

    let h = hub().await;

    let app = &h.app;

    register(app, "andy").await;

    let work = tempfile::tempdir().unwrap();

    delegate(app, "andy", work.path()).await;

    let t = admin_token(app, "andy").await;

    let r = api(app, "POST", "/repos", Some(&t), Some(serde_json::json!({ "owner": "andy", "name": "pong" }))).await;

    assert_eq!(r.status, StatusCode::CREATED, "{}", r.body);

    // No assistant yet: none offered, and asking says where to set one up.

    let r = api(app, "GET", "/user/starter?owner=andy", Some(&t), None).await;

    assert_eq!(r.body, r#"{"assistants":[]}"#);

    let ask = serde_json::json!({ "description": "A pong game in Rust" });

    let r = api(app, "POST", "/repos/andy/pong/starter", Some(&t), Some(ask.clone())).await;

    assert_eq!(r.status, StatusCode::UNPROCESSABLE_ENTITY, "{}", r.body);

    assert!(r.body.contains("no assistant is set up"), "{}", r.body);

    // The site's assistant.

    let ep = model().await;

    let body = serde_json::json!({ "name": "Helper", "endpoint": ep, "api": "chat-completions", "model": "m1" });

    let r = api(app, "POST", "/admin/assistants", Some(&t), Some(body)).await;

    assert_eq!(r.status, StatusCode::OK, "{}", r.body);

    let r = api(app, "GET", "/user/starter?owner=andy", Some(&t), None).await;

    let v: serde_json::Value = serde_json::from_str(&r.body).unwrap();

    assert_eq!((v["assistants"][0]["name"].as_str(), v["assistants"][0]["from"].as_str()), (Some("Helper"), Some("the site")), "{v}");

    // Asked: it works in the background, then the files are the repository's first change.

    let r = api(app, "POST", "/repos/andy/pong/starter", Some(&t), Some(ask.clone())).await;

    assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);

    let v = wait_done(app, "andy/pong", &t).await;

    assert_eq!(v["status"], "done", "{v}");

    assert_eq!(v["files"], serde_json::json!(["README.md", "src/main.rs"]));

    assert_eq!(v["assistant"], "Helper");

    let r = api(app, "GET", "/repos/andy/pong/file/main/README.md", Some(&t), None).await;

    assert!(r.body.contains("A small pong game."), "{}", r.body);

    let r = api(app, "GET", "/repos/andy/pong/history/main", Some(&t), None).await;

    assert!(r.body.contains("Starter files drafted by Helper (m1)") && r.body.contains("A pong game in Rust"), "{}", r.body);

    // Never over files that are there, and the request must say something.

    let r = api(app, "POST", "/repos/andy/pong/starter", Some(&t), Some(ask)).await;

    assert_eq!(r.status, StatusCode::CONFLICT, "{}", r.body);

    api(app, "POST", "/repos", Some(&t), Some(serde_json::json!({ "owner": "andy", "name": "empty" }))).await;

    let r = api(app, "POST", "/repos/andy/empty/starter", Some(&t), Some(serde_json::json!({ "description": "  " }))).await;

    assert_eq!(r.status, StatusCode::UNPROCESSABLE_ENTITY, "{}", r.body);

    // An answer with no files fails, saying so, and the repository stays empty.

    let r =

        api(app, "POST", "/repos/andy/empty/starter", Some(&t), Some(serde_json::json!({ "description": "make-no-files please" }))).await;

    assert_eq!(r.status, StatusCode::ACCEPTED, "{}", r.body);

    let v = wait_done(app, "andy/empty", &t).await;

    assert_eq!(v["status"], "failed", "{v}");

    assert!(v["error"].as_str().unwrap().contains("without any files"), "{v}");

    assert_eq!(api(app, "GET", "/repos/andy/empty/starter", None, None).await.status, StatusCode::OK, "readable as the repository is");

    // Someone who has not delegated to the hub is told how.

    register(app, "bob").await;

    let b = admin_token(app, "bob").await;

    assert_eq!(

        api(app, "GET", "/user/starter?owner=andy", Some(&b), None).await.body,

        r#"{"assistants":[]}"#,

        "not an owner bob creates under"

    );

    api(app, "POST", "/repos", Some(&b), Some(serde_json::json!({ "owner": "bob", "name": "game" }))).await;

    let r = api(app, "POST", "/repos/bob/game/starter", Some(&b), Some(serde_json::json!({ "description": "A game" }))).await;

    assert_eq!(r.status, StatusCode::UNPROCESSABLE_ENTITY, "{}", r.body);

    assert!(r.body.contains("delegated"), "{}", r.body);

}