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

//! person creating it describes what they want, an assistant set up for the

//! owner (the site's, or the organisation's) answers with files, and the

//! hub commits them to the empty repository's default bookmark, authored by

//! that person and signed by the hub as their delegate, as a web edit is.

//! The change says which assistant drafted it and what was asked. It runs

//! in the background, since a model may take longer than a proxied request

//! may last; its state is kept here until the hub restarts.

use crate::assistants::{self, Assistant, Available, Scope};

use crate::db::{self, Pool};

use crate::repos::RepoName;

use crate::Shared;

use oxy_core::repo::FileEdit;

use std::collections::HashMap;

use std::path::PathBuf;

use std::sync::{LazyLock, Mutex};

/// The most a description may say.

pub const MAX_DESCRIPTION: usize = 4000;

/// The most files a starter may have, the largest one and all of them.

pub const MAX_FILES: usize = 40;

pub const MAX_FILE: usize = 64 * 1024;

pub const MAX_TOTAL: usize = 256 * 1024;

/// The assistants a new repository under `owner` may ask: the site's, and

/// the organisation's when `owner` is one, as its repositories would see.

pub async fn assistants_for(pool: &Pool, owner: &str) -> sqlx::Result<Vec<Available>> {

    let scope = match db::accounts::org_by_name(pool, owner).await? {

        Some(org) => Scope::Org(org.id),

        None => Scope::Site,

    };

    Ok(assistants::available(pool, scope, owner).await?.into_iter().filter(Available::on).collect())

}

/// Where a repository's starter stands.

#[derive(Clone, Debug, PartialEq, Eq)]

pub enum State {

    Running { assistant: String },

    Done { assistant: String, change: String, files: Vec<String> },

    Failed { assistant: String, error: String },

}

static STATES: LazyLock<Mutex<HashMap<PathBuf, State>>> = LazyLock::new(|| Mutex::new(HashMap::new()));

fn key(app: &Shared, name: &RepoName) -> PathBuf {

    app.repos.dir(name)

}

/// The starter of `name` on this hub, if one was asked for since it started.

pub fn state(app: &Shared, name: &RepoName) -> Option<State> {

    STATES.lock().unwrap_or_else(|p| p.into_inner()).get(&key(app, name)).cloned()

}

fn set(app: &Shared, name: &RepoName, s: State) {

    STATES.lock().unwrap_or_else(|p| p.into_inner()).insert(key(app, name), s);

}

/// What the assistant is told: what to write and the one shape to answer in.

pub fn system_prompt(a: &Assistant, site: &str, owner_prompts: &str) -> String {

    let mut s = format!(

        "You are {name}, an AI assistant writing the first files of a new repository on {site}, an OxygenHub site, \

         for the person who just created it; they read, change and own everything you write. \

         Make a small, working starting point for what they describe: a README.md saying what it is and how to build, \

         run and test it; the build files the language's own tools expect; a minimal source layout; and a first test \

         where the ecosystem has a convention. No secrets, no placeholder credentials, no binary files, nothing \

         generated (lock files, build output). At most {MAX_FILES} files.\n\n\

         Answer with files only, each written as\n\n\

         <<<FILE path/from/the/repository/root>>>\n\

         the file's whole content\n\

         <<<END>>>\n\n\

         with nothing before the first file and nothing after the last.",

        name = a.name

    );

    if !owner_prompts.trim().is_empty() {

        s.push_str("\n\n");

        s.push_str(owner_prompts.trim());

    }

    s

}

/// The files an answer holds, checked: relative paths without `..`, text,

/// within the limits. `Err` says what was wrong, for the person who asked.

pub fn parse_files(answer: &str) -> Result<Vec<(String, String)>, String> {

    let mut files: Vec<(String, String)> = vec![];

    let mut current: Option<(String, Vec<&str>)> = None;

    for line in answer.lines() {

        let t = line.trim_end();

        if let Some((path, body)) = current.as_mut() {

            if t.trim() == "<<<END>>>" {

                let path = std::mem::take(path);

                let content = body.join("\n") + "\n";

                current = None;

                files.push((path, content));

            } else {

                body.push(line);

            }

            continue;

        }

        if let Some(rest) = t.trim().strip_prefix("<<<FILE ") {

            let path = rest.strip_suffix(">>>").ok_or_else(|| format!("a file line is not closed with >>>: {t:?}"))?.trim();

            current = Some((path.to_string(), vec![]));

        }

    }

    if let Some((path, _)) = current {

        return Err(format!("the answer stopped inside {path:?} (no <<<END>>>)"));

    }

    if files.is_empty() {

        return Err("the assistant answered without any files".into());

    }

    if files.len() > MAX_FILES {

        return Err(format!("the assistant wrote {} files; a starter has at most {MAX_FILES}", files.len()));

    }

    let mut total = 0;

    let mut seen = std::collections::BTreeSet::new();

    for (path, content) in &files {

        check_path(path)?;

        if !seen.insert(path.clone()) {

            return Err(format!("the assistant wrote {path} twice"));

        }

        if content.len() > MAX_FILE {

            return Err(format!("{path} is {} bytes; a starter's files are at most {MAX_FILE}", content.len()));

        }

        if content.contains('\0') {

            return Err(format!("{path} is not text"));

        }

        total += content.len();

    }

    if total > MAX_TOTAL {

        return Err(format!("the starter is {total} bytes; at most {MAX_TOTAL}"));

    }

    Ok(files)

}

fn check_path(path: &str) -> Result<(), String> {

    let bad = |why: &str| Err(format!("the path {path:?} {why}"));

    if path.is_empty() || path.len() > 200 {

        return bad("is empty or longer than 200 characters");

    }

    if path.starts_with('/') || path.contains('\\') || path.contains(':') {

        return bad("is not relative to the repository's root");

    }

    for part in path.split('/') {

        if part.is_empty() || part == "." || part == ".." {

            return bad("has an empty, . or .. part");

        }

        if part.eq_ignore_ascii_case(".oxy") {

            return bad("is inside the repository's own metadata");

        }

        if part.chars().any(char::is_control) {

            return bad("has a control character");

        }

    }

    Ok(())

}

/// Whether `name`'s default bookmark holds nothing yet.

pub async fn is_empty(app: &Shared, name: &RepoName, bookmark: &str) -> Result<bool, String> {

    let b = bookmark.to_string();

    app.repos

        .read(name, move |r, _| {

            let view = r.view()?;

            Ok(match view.bookmarks.get(&b) {

                None => true,

                Some(st) => r.store().get_state(st)?.heads.is_empty(),

            })

        })

        .await

        .map_err(|e| e.to_string())

}

/// Ask `a` for `row`'s starting files in the background, for `by`, and

/// commit them; [`state`] follows it.

pub fn start(app: Shared, row: db::repos::RepoRow, by: db::accounts::Account, a: Assistant, description: String) {

    let Some(name) = RepoName::new(&row.owner, &row.name) else { return };

    set(&app, &name, State::Running { assistant: a.name.clone() });

    tokio::spawn(async move {

        let outcome = run(&app, &row, &by, &a, &description).await;

        let s = match outcome {

            Ok((change, files)) => State::Done { assistant: a.name.clone(), change, files },

            Err(error) => {

                tracing::warn!("starter for {}/{}: {error}", row.owner, row.name);

                State::Failed { assistant: a.name.clone(), error }

            }

        };

        set(&app, &name, s);

    });

}

async fn run(

    app: &Shared,

    row: &db::repos::RepoRow,

    by: &db::accounts::Account,

    a: &Assistant,

    description: &str,

) -> Result<(String, Vec<String>), String> {

    let name = RepoName::new(&row.owner, &row.name).ok_or("bad repository name")?;

    let signer = crate::web::edit::signer_for(app, by.id).await?;

    let scope = match db::accounts::org_by_name(&app.db, &row.owner).await.map_err(|e| e.to_string())? {

        Some(org) => Scope::Org(org.id),

        None => Scope::Site,

    };

    let mut prompts = assistants::inherited_prompts(&app.db, scope, &row.owner).await.map_err(|e| e.to_string())?;

    let own = assistants::prompt(&app.db, scope).await.map_err(|e| e.to_string())?;

    if !own.is_empty() && scope != Scope::Site {

        prompts.push((format!("the {} organisation", row.owner), own));

    } else if !own.is_empty() {

        prompts.push(("the site".to_string(), own));

    }

    let prompts: String =

        prompts.into_iter().map(|(from, text)| format!("## Instructions from {from}\n\n{text}\n")).collect::<Vec<_>>().join("\n");

    let site = app.config.base_url();

    let user = format!("The repository is {}/{}.\n\nWhat they want:\n\n{}", row.owner, row.name, description.trim());

    let answer = assistants::ask(app, a, &system_prompt(a, site, &prompts), &user, assistants::BACKGROUND_TIMEOUT).await?;

    let files = parse_files(&answer)?;

    if !is_empty(app, &name, &row.default_bookmark).await? {

        return Err("the repository has files now, so the starter was not added".into());

    }

    let paths: Vec<String> = files.iter().map(|(p, _)| p.clone()).collect();

    let edits: Vec<FileEdit> = files.into_iter().map(|(path, content)| FileEdit { path, content: Some(content.into_bytes()) }).collect();

    let short: String = description.trim().chars().take(400).collect();

    let message = format!("Starter files drafted by {} ({})\n\nAsked for by {}: {short}", a.name, a.model, by.username);

    let b = row.default_bookmark.clone();

    let done = crate::repos::edits::commit(&app.repos, &name, b.clone(), b, edits, message, signer).await.map_err(|e| e.to_string())?;

    db::accounts::audit(&app.db, Some(by), "repo.starter", &name.to_string(), &format!("{} files drafted by {}", paths.len(), a.name))

        .await

        .ok();

    Ok((done.change.to_hex(), paths))

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn an_answer_is_read_as_files_and_checked() {

        let answer = "<<<FILE README.md>>>\n# Hello\n<<<END>>>\n<<<FILE src/main.rs>>>\nfn main() {}\n<<<END>>>\n";

        let files = parse_files(answer).unwrap();

        assert_eq!(

            files,

            vec![("README.md".to_string(), "# Hello\n".to_string()), ("src/main.rs".to_string(), "fn main() {}\n".to_string())]

        );

        assert!(parse_files("Sure! Here you go.").unwrap_err().contains("without any files"));

        assert!(parse_files("<<<FILE a>>>\nx").unwrap_err().contains("no <<<END>>>"));

        for bad in ["/etc/passwd", "../up", "a//b", "C:\\x", ".oxy/config"] {

            assert!(parse_files(&format!("<<<FILE {bad}>>>\nx\n<<<END>>>")).is_err(), "{bad}");

        }

        assert!(parse_files("<<<FILE a>>>\n1\n<<<END>>>\n<<<FILE a>>>\n2\n<<<END>>>").unwrap_err().contains("twice"));

        let many: String = (0..=MAX_FILES).map(|i| format!("<<<FILE f{i}>>>\nx\n<<<END>>>\n")).collect();

        assert!(parse_files(&many).unwrap_err().contains("at most"));

        let big = format!("<<<FILE big>>>\n{}\n<<<END>>>", "x".repeat(MAX_FILE + 1));

        assert!(parse_files(&big).unwrap_err().contains("at most"));

    }

}