//! Creating repositories and their settings pages (hub spec §6.3).

use super::settings::{csrf, require};

use super::{filters, lookup_role, Error, Page, RepoShell, Shell};

use crate::auth::{roles, Access, Role, Viewer};

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

use crate::repos::RepoName;

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, State};

use axum::response::{IntoResponse, Redirect, Response};

use hub_api::Visibility;

use serde::Deserialize;

#[derive(Template)]

#[template(path = "repo_new.html")]

pub struct NewRepoPage {

    shell: Shell,

    owners: Vec<String>,

    error: Option<String>,

}

pub(crate) async fn owners_for(app: &Shared, me: &accounts::Account) -> Vec<String> {

    let mut owners = vec![me.username.clone()];

    if let Ok(orgs) = accounts::orgs_of(&app.db, me.id).await {

        owners.extend(orgs.into_iter().map(|(o, _)| o.name));

    }

    owners

}

pub async fn new_form(State(app): State<Shared>, viewer: Viewer) -> Result<Page<NewRepoPage>, Error> {

    let shell = Shell::new(&app, "/new", &viewer);

    let me = require(&viewer, &shell)?;

    let owners = owners_for(&app, &me.account).await;

    Ok(Page(NewRepoPage { shell, owners, error: None }))

}

#[derive(Deserialize)]

pub struct NewRepoForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    owner: String,

    name: String,

    #[serde(default)]

    description: String,

    #[serde(default = "default_visibility")]

    visibility: String,

}

fn default_visibility() -> String {

    "public".into()

}

pub async fn create(State(app): State<Shared>, viewer: Viewer, Form(f): Form<NewRepoForm>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/new", &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let owners = owners_for(&app, &me.account).await;

    let fail = |msg: &str| Page(NewRepoPage { shell: shell.clone(), owners: owners.clone(), error: Some(msg.into()) }).into_response();

    let Some(name) = RepoName::new(f.owner.trim(), f.name.trim()) else {

        return Ok(fail("A repository name is letters, digits, dots, dashes and underscores."));

    };

    if !roles::may_create_under(&app.db, &me.account, &name.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        return Ok(fail("You cannot create repositories under that owner."));

    }

    let Some(visibility) = Visibility::parse(&f.visibility) else { return Ok(fail("Visibility is public, internal or private.")) };

    if db::repos::get(&app.db, &name.owner, &name.name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()

        || app.repos.exists(&name)

    {

        return Ok(fail("That repository exists."));

    }

    app.repos.create(&name, None).map_err(|e| Error::from_repo(shell.clone(), e))?;

    db::repos::create(&app.db, &name.owner, &name.name, f.description.trim(), visibility)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me.account), "repo.created", &name.to_string(), visibility.as_str()).await.ok();

    Ok(Redirect::to(&name.url()).into_response())

}

#[derive(Template)]

#[template(path = "repo_settings.html")]

pub struct RepoSettingsPage {

    shell: Shell,

    repo: RepoShell,

    row: db::repos::RepoRow,

    collaborators: Vec<accounts::Collaborator>,

    teams: Vec<accounts::Team>,

    role: Role,

    requirements: db::proposals::Requirements,

    hooks: Vec<super::webhooks::HookRow>,

    required_checks: String,

    /// Whether hub.toml alone would run Flow here, and whether it runs.

    flow_default: bool,

    flow_enabled: bool,

    site_admin: bool,

    notice: Option<String>,

    error: Option<String>,

    /// Runners that may take this repository's jobs: (runner, what it

    /// serves, whether it is this repository's own).

    runners: Vec<(db::runners::Runner, String, bool)>,

    /// A registration token just made, shown once.

    runner_token: Option<String>,

}

async fn settings_page(

    app: &Shared,

    shell: Shell,

    row: db::repos::RepoRow,

    role: Role,

    notice: Option<String>,

    error: Option<String>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let collaborators = accounts::collaborators(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let teams = match accounts::org_by_name(&app.db, &row.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        Some(org) => accounts::teams(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,

        None => vec![],

    };

    let repo = RepoShell::new(app, &row, "settings").with_role(role);

    let requirements = db::proposals::requirements(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let hooks = db::hooks::hooks_for_repo(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let hooks = super::webhooks::rows(app, hooks).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let required_checks = db::hooks::required_checks(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.join(", ");

    let flow_default = app.config.flow.allows(&row.owner, &row.name);

    let flow_enabled = crate::flow::enabled(app, &row);

    let site_admin = shell.is_admin;

    let runners = db::runners::serving(&app.db, &row.owner, row.id)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?

        .into_iter()

        .map(|r| {

            let own = r.scope_repo_id == Some(row.id);

            let serves = if own {

                "this repository".to_string()

            } else if r.scope_owner.is_empty() {

                "the whole site".to_string()

            } else {

                format!("{}'s repositories", r.scope_owner)

            };

            (r, serves, own)

        })

        .collect();

    Ok(Page(RepoSettingsPage {

        runners,

        runner_token: None,

        shell,

        repo,

        row,

        collaborators,

        teams,

        role,

        requirements,

        hooks,

        required_checks,

        flow_default,

        flow_enabled,

        site_admin,

        notice,

        error,

    }))

}

pub async fn settings(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    settings_page(&app, shell, row, role, None, None).await

}

#[derive(Deserialize)]

pub struct GeneralForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    description: String,

    default_bookmark: String,

    visibility: String,

    #[serde(default)]

    topics: String,

}

pub async fn update(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<GeneralForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let topics = match db::repos::parse_topics(&f.topics) {

        Ok(t) => t,

        Err(msg) => return settings_page(&app, shell, row, role, None, Some(msg)).await,

    };

    db::repos::set_description(&app.db, row.id, f.description.trim()).await.map_err(e)?;

    db::repos::set_topics(&app.db, row.id, &topics).await.map_err(e)?;

    if crate::repos::names::valid_segment(f.default_bookmark.trim()) {

        db::repos::set_default_bookmark(&app.db, row.id, f.default_bookmark.trim()).await.map_err(e)?;

    }

    if role >= Role::Admin {

        if let Some(v) = Visibility::parse(&f.visibility) {

            db::repos::set_visibility(&app.db, row.id, v).await.map_err(e)?;

        }

    }

    accounts::audit(&app.db, viewer.account(), "repo.updated", &format!("{owner}/{name}"), "").await.ok();

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(e)?.unwrap_or(row);

    settings_page(&app, shell, row, role, Some("Saved.".into()), None).await

}

#[derive(Deserialize)]

pub struct CollaboratorForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    username: String,

    #[serde(default)]

    team: String,

    #[serde(default)]

    role: String,

    #[serde(default)]

    remove: Option<String>,

}

pub async fn collaborator(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<CollaboratorForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let e = |e| Error::from_db(shell.clone(), e);

    let (account_id, team_id, label) = if !f.username.trim().is_empty() {

        match accounts::account_by_name(&app.db, f.username.trim()).await.map_err(e)? {

            Some(a) => (Some(a.id), None, a.username),

            None => return settings_page(&app, shell, row, role, None, Some("No such account.".into())).await,

        }

    } else if !f.team.trim().is_empty() {

        let org = accounts::org_by_name(&app.db, &row.owner).await.map_err(e)?;

        let team = match org {

            Some(o) => accounts::team_by_name(&app.db, o.id, f.team.trim()).await.map_err(e)?,

            None => None,

        };

        match team {

            Some(t) => (None, Some(t.id), format!("team {}", t.name)),

            None => return settings_page(&app, shell, row, role, None, Some("No such team in this organisation.".into())).await,

        }

    } else {

        return settings_page(&app, shell, row, role, None, Some("Name an account or a team.".into())).await;

    };

    if f.remove.is_some() {

        accounts::remove_collaborator(&app.db, row.id, account_id, team_id).await.map_err(e)?;

        accounts::audit(&app.db, viewer.account(), "repo.collaborator.removed", &format!("{owner}/{name}"), &label).await.ok();

        return settings_page(&app, shell, row, role, Some(format!("Removed {label}.")), None).await;

    }

    let Some(new_role) = Role::parse(&f.role) else {

        return settings_page(&app, shell, row, role, None, Some("Pick a role.".into())).await;

    };

    accounts::set_collaborator(&app.db, row.id, account_id, team_id, new_role.as_str()).await.map_err(e)?;

    accounts::audit(

        &app.db,

        viewer.account(),

        "repo.collaborator.set",

        &format!("{owner}/{name}"),

        &format!("{label} {}", new_role.as_str()),

    )

    .await

    .ok();

    settings_page(&app, shell, row, role, Some(format!("{label} now has {} access.", new_role.as_str())), None).await

}

#[derive(Deserialize)]

pub struct DeleteForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    confirm: String,

}

pub async fn delete(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<DeleteForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (repo, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    if f.confirm.trim() != repo.to_string() {

        return Ok(settings_page(&app, shell, row, role, None, Some("Type the repository's full name to delete it.".into()))

            .await?

            .into_response());

    }

    let _guard = app.repos.write_guard(&repo).await;

    app.repos.trash(&repo).map_err(|e| Error::from_repo(shell.clone(), e))?;

    db::repos::delete(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, viewer.account(), "repo.deleted", &repo.to_string(), "moved to trash").await.ok();

    Ok(Redirect::to(&format!("/{owner}")).into_response())

}

#[derive(Deserialize)]

pub struct RequirementsForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    required_approvals: i64,

    #[serde(default)]

    require_owners: Option<String>,

    #[serde(default)]

    allow_conflicts: Option<String>,

}

pub async fn requirements(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<RequirementsForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let r = db::proposals::Requirements {

        required_approvals: f.required_approvals.max(0),

        require_owners: f.require_owners.is_some(),

        allow_conflicts: f.allow_conflicts.is_some(),

    };

    db::proposals::set_requirements(&app.db, row.id, r).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(

        &app.db,

        viewer.account(),

        "repo.requirements",

        &format!("{owner}/{name}"),

        &format!("{} approvals, owners {}, conflicts {}", r.required_approvals, r.require_owners, r.allow_conflicts),

    )

    .await

    .ok();

    settings_page(&app, shell, row, role, Some("Landing requirements saved.".into()), None).await

}

pub async fn hooks(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<super::webhooks::HookForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };

    match super::webhooks::apply(&app, &viewer, &scope, f).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        Ok(notice) => settings_page(&app, shell, row, role, Some(notice), None).await,

        Err(error) => settings_page(&app, shell, row, role, None, Some(error)).await,

    }

}

pub async fn deliveries(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };

    super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), id).await

}

pub async fn redeliver(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id, delivery)): Path<(String, String, i64, i64)>,

    Form(f): Form<super::session::CsrfForm>,

) -> Result<Page<super::webhooks::DeliveriesPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings/hooks/{id}/deliveries"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Admin).await?;

    csrf(&viewer, &f.csrf, &shell)?;

    let scope = super::webhooks::Scope::Repo { id: row.id, slug: format!("{owner}/{name}") };

    super::webhooks::redeliver(&app, &scope, id, delivery).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    super::webhooks::deliveries_page(&app, shell, &scope, Some(RepoShell::new(&app, &row, "settings").with_role(role)), id).await

}

#[derive(Deserialize)]

pub struct ChecksForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    required_checks: String,

}

pub async fn required_checks(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<ChecksForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let names: Vec<String> = f.required_checks.split(',').map(str::trim).filter(|s| !s.is_empty()).map(String::from).collect();

    db::hooks::set_required_checks(&app.db, row.id, &names).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    settings_page(&app, shell, row, role, Some("Required checks saved.".into()), None).await

}

#[derive(Deserialize)]

pub struct MirrorForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    enabled: Option<String>,

}

#[derive(Deserialize)]

pub struct FlowForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    /// `on`, `off`, or `default`.

    flow: String,

}

/// Turn OxygenFlow on or off for one repository. Runs use the site's

/// runners, so only site administrators decide.

pub async fn flow(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<FlowForm>,

) -> Result<Page<RepoSettingsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/settings"), &viewer);

    let (_, row, role) = lookup_role(&app, &shell, &viewer, &owner, &name, Access::Maintain).await?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    if !viewer.is_admin() {

        return settings_page(&app, shell, row, role, None, Some("Only site administrators turn OxygenFlow on or off.".into())).await;

    }

    let setting = match f.flow.as_str() {

        "on" => "on",

        "off" => "off",

        "default" => "",

        _ => return settings_page(&app, shell, row, role, None, Some("Pick on, off or the site default.".into())).await,

    };

    db::repos::set_flow(&app.db, row.id, setting).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let label = if setting.is_empty() { "default" } else { setting };

    accounts::audit(&app.db, viewer.account(), "repo.flow", &format!("{owner}/{name}"), label).await.ok();

    let row = db::repos::get_by_id(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?.unwrap_or(row);

    let notice = if crate::flow::enabled(&app, &row) {

        "OxygenFlow is on: pushes with a .flow/pipeline.kdl start runs."

    } else {

        "OxygenFlow is off for this repository."

    };

    settings_page(&app, shell, row, role, Some(notice.into()), None).await

}

pub async fn mirror(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,