//! 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, Query, State};

use axum::http::Uri;

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>,

    /// The open boards of each owner the viewer may change, for "add it to

    /// an existing board" (#360): (owner, number, title).

    boards: Vec<(String, i64, String)>,

    /// Owners that are organisations: a board is on by default for them.

    orgs: Vec<String>,

    licences: &'static [(&'static str, &'static str)],

    ignores: &'static [&'static str],

    base_url: String,

    /// Whether the viewer may put a repository on the site's runners (#371).

    admin: bool,

    /// Owners with runners of their own, for "on its owner's runners".

    runner_owners: Vec<String>,

    /// Each owner's default bookmark and where it comes from (#371).

    bookmarks: Vec<(String, String, String)>,

}

/// The New repository page's choices for `me` (#360).

async fn new_page(app: &Shared, shell: Shell, me: &accounts::Account, error: Option<String>) -> NewRepoPage {

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

    let mut boards = Vec::new();

    let mut orgs = Vec::new();

    let mut runner_owners = Vec::new();

    let mut bookmarks = Vec::new();

    for o in &owners {

        let (b, from) = crate::repo_setup::default_bookmark_for(app, o).await;

        bookmarks.push((o.clone(), b, from));

        if crate::repo_setup::owner_has_runner(app, o).await.unwrap_or(false) {

            runner_owners.push(o.clone());

        }

        if accounts::org_by_name(&app.db, o).await.ok().flatten().is_some() {

            orgs.push(o.clone());

        }

        let may = crate::web::projects::rights_of(app, Some(me), o).await.ok().flatten().is_some_and(|r| r.edit);

        if may {

            for p in db::projects::of_owner(&app.db, o).await.unwrap_or_default().into_iter().filter(|p| !p.closed) {

                boards.push((o.clone(), p.number, p.title));

            }

        }

    }

    NewRepoPage {

        shell,

        owners,

        error,

        boards,

        orgs,

        licences: crate::repo_setup::LICENCES,

        ignores: crate::repo_setup::IGNORES,

        base_url: app.config.base_url().trim_end_matches('/').to_string(),

        admin: me.is_admin,

        runner_owners,

        bookmarks,

    }

}

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)?;

    Ok(Page(new_page(&app, shell, &me.account, None).await))

}

#[derive(Deserialize)]

pub struct NameCheck {

    #[serde(default)]

    owner: String,

    #[serde(default)]

    name: String,

}

/// `GET /new/check?owner=&name=` (#360): the page's live check that a name

/// is free and valid, answering `{"ok", "message", "address"}`.

pub async fn check_name(State(app): State<Shared>, viewer: Viewer, Query(q): Query<NameCheck>) -> Response {

    let Some(me) = viewer.account() else {

        return (axum::http::StatusCode::UNAUTHORIZED, axum::Json(serde_json::json!({"ok": false, "message": "Sign in first."})))

            .into_response();

    };

    if q.name.trim().is_empty() {

        return axum::Json(serde_json::json!({"ok": false, "message": ""})).into_response();

    }

    match crate::repo_setup::check_name(&app, me, &q.owner, &q.name).await {

        Ok(n) => axum::Json(serde_json::json!({

            "ok": true,

            "message": format!("{n} is free."),

            "address": format!("{}{}", app.config.base_url().trim_end_matches('/'), n.url()),

        }))

        .into_response(),

        Err(m) => axum::Json(serde_json::json!({"ok": false, "message": m})).into_response(),

    }

}

#[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,

    /// `hub` (this server's disk, the default) or `bucket` (oxygenhub#96).

    #[serde(default)]

    storage: String,

    #[serde(flatten)]

    bucket: BucketForm,

    /// What it starts with (#360): a README, a licence, an `.oxyignore`.

    #[serde(default)]

    readme: Option<String>,

    #[serde(default)]

    licence: String,

    #[serde(default)]

    ignore: String,

    /// A board with it: `new` (titled `board_title`), a board number, or none.

    #[serde(default)]

    board: String,

    #[serde(default)]

    board_title: String,

    /// The existing board's number, with `board=existing`.

    #[serde(default)]

    board_n: String,

    /// OxygenFlow (#371): `on`, `own`, or the site default.

    #[serde(default)]

    flow: String,

    /// Start the wiki with a Home page (#371).

    #[serde(default)]

    wiki: Option<String>,

    /// Its default bookmark; empty, the owner's or the site's default (#371).

    #[serde(default)]

    default_bookmark: String,

}

/// A bucket and the credentials for it, as the New repository form and

/// Settings → Storage give them; only the kind the URL names is read.

#[derive(Deserialize, Default)]

pub struct BucketForm {

    #[serde(default)]

    store_url: String,

    #[serde(default)]

    access_key_id: String,

    #[serde(default)]

    secret_access_key: String,

    #[serde(default)]

    service_account_key: String,

    #[serde(default)]

    tenant_id: String,

    #[serde(default)]

    client_id: String,

    #[serde(default)]

    client_secret: String,

}

impl BucketForm {

    fn credentials(&self, scheme: &str) -> Result<oxy_strata::Credentials, String> {

        crate::storage::credentials_from(

            scheme,

            &self.access_key_id,

            &self.secret_access_key,

            &self.service_account_key,

            &self.tenant_id,

            &self.client_id,

            &self.client_secret,

        )

    }

}

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 page = new_page(&app, shell.clone(), &me.account, None).await;

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

    let name = match crate::repo_setup::check_name(&app, &me.account, &f.owner, &f.name).await {

        Ok(n) => n,

        Err(m) => return Ok(fail(&m)),

    };

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

    // Its board and its starting files are checked before anything is made (#360).

    let choice = if f.board == "existing" { f.board_n.as_str() } else { f.board.as_str() };

    let board = match crate::repo_setup::Board::parse(choice, &f.board_title, &name.name) {

        Ok(b) => b,

        Err(m) => return Ok(fail(&m)),

    };

    if let Err(m) = crate::repo_setup::check_board(&app, &me.account, &name.owner, &board).await {

        return Ok(fail(&m));

    }

    let flow = match crate::repo_setup::Flow::parse(&f.flow) {

        Ok(flow) => flow,

        Err(m) => return Ok(fail(&m)),

    };

    if let Err(m) = crate::repo_setup::check_flow(&app, &me.account, &name.owner, flow).await {

        return Ok(fail(&m));

    }

    let wiki = f.wiki.is_some();

    if !f.default_bookmark.trim().is_empty() {

        if let Err(m) = crate::repo_setup::check_bookmark(f.default_bookmark.trim()) {

            return Ok(fail(&m));

        }

    }

    let start =

        crate::repo_setup::Start { readme: f.readme.is_some(), licence: f.licence.trim().to_string(), ignore: f.ignore.trim().to_string() };

    let year = time::OffsetDateTime::now_utc().year();

    let holder = if me.account.display_name.trim().is_empty() { me.account.username.clone() } else { me.account.display_name.clone() };

    let files = match start.files(&name, &f.description, &holder, year) {

        Ok(files) => files,

        Err(m) => return Ok(fail(&m)),

    };

    if !files.is_empty() && f.storage == "bucket" {

        return Ok(fail("A repository kept in your own bucket starts empty: push its first files to it."));

    }

    if !files.is_empty() || wiki {

        if let Err(m) = crate::web::edit::signer_for(&app, me.account.id).await {

            return Ok(fail(&format!("The hub cannot write the starting files or the wiki for you yet. {m}")));

        }

    }

    // An organisation's storage policy (oxygenhub#96).

    if let Some(org) = accounts::org_by_name(&app.db, &name.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        let policy = crate::storage::policy(&app.db, org.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        let store = (f.storage == "bucket").then_some(f.bucket.store_url.as_str());

        if let Err(e) = policy.permits(&org.name, store) {

            return Ok(fail(&format!("{e}.")));

        }

    }

    if f.storage == "bucket" {

        // Kept in the owner's bucket (oxygenhub#96): checked before

        // anything is made, and nothing is left behind when it fails.

        let url = f.bucket.store_url.trim();

        let parsed = match crate::storage::check_url(url) {

            Ok(p) => p,

            Err(e) => return Ok(fail(&format!("Store: {e}."))),

        };

        let credentials = match f.bucket.credentials(&parsed.scheme) {

            Ok(c) => c,

            Err(e) => return Ok(fail(&format!("Credentials: {e}."))),

        };

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

            .await

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

        let row =

            crate::repo_setup::set_default_bookmark(&app, row, &f.default_bookmark).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        if let Err(e) = crate::storage::create(&app, &name, row.id, url, credentials).await {

            db::repos::delete(&app.db, row.id).await.ok();

            return Ok(fail(&format!("The bucket did not pass the check, so nothing was created: {e}")));

        }

        accounts::audit(

            &app.db,

            Some(&me.account),

            "repo.created",

            &name.to_string(),

            &format!("{} in {}", visibility.as_str(), parsed.plain()),

        )

        .await

        .ok();

        crate::repo_setup::link_board(&app, &row, &board, visibility == Visibility::Public)

            .await

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

        crate::repo_setup::set_flow(&app, &row, &me.account, flow).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        if wiki {

            if let Err(e) = crate::repo_setup::start_wiki(&app, &row, &me.account, &f.description).await {

                tracing::warn!("wiki for {name}: {e}");

            }

        }

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

    }

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

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

        .await

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

    let row =

        crate::repo_setup::set_default_bookmark(&app, row, &f.default_bookmark).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();

    crate::repo_setup::link_board(&app, &row, &board, visibility == Visibility::Public)

        .await

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

    crate::repo_setup::set_flow(&app, &row, &me.account, flow).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if let Err(e) = crate::repo_setup::commit_start(&app, &row, &me.account, files).await {

        tracing::warn!("starting files for {name}: {e}");

    }

    if wiki {

        if let Err(e) = crate::repo_setup::start_wiki(&app, &row, &me.account, &f.description).await {

            tracing::warn!("wiki for {name}: {e}");

        }

    }

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

}

fn clone_page(p: &NewRepoPage) -> NewRepoPage {

    NewRepoPage {

        shell: p.shell.clone(),

        owners: p.owners.clone(),

        error: p.error.clone(),

        boards: p.boards.clone(),

        orgs: p.orgs.clone(),

        licences: p.licences,

        ignores: p.ignores,

        base_url: p.base_url.clone(),

        admin: p.admin,

        runner_owners: p.runner_owners.clone(),

        bookmarks: p.bookmarks.clone(),

    }

}

/// One page of a repository's settings (#278), at

/// `/{owner}/{name}/settings/{slug}`; `/settings` is General.

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

pub enum Section {

    General,

    Collaborators,

    Landing,

    Checks,

    PushProtection,

    Pipelines,

    Runs,

    Gates,

    Runners,

    Variables,

    Secrets,

    Coverage,

    Webhooks,

    Assistants,

    GitMirror,

    Diffusion,

    Storage,

    Backup,

    Advanced,

}

/// The sidebar: each group's heading and its pages, in order.

const GROUPS: &[(&str, &[Section])] = &[

    ("General", &[Section::General, Section::Collaborators]),

    ("Code", &[Section::Landing, Section::Checks, Section::PushProtection]),

    (

        "Flow",

        &[Section::Pipelines, Section::Runs, Section::Gates, Section::Runners, Section::Variables, Section::Secrets, Section::Coverage],

    ),

    ("Integrations", &[Section::Webhooks, Section::Assistants, Section::GitMirror, Section::Diffusion]),

    ("Data", &[Section::Storage, Section::Backup]),

    ("Danger zone", &[Section::Advanced]),

];

impl Section {

    pub fn slug(self) -> &'static str {

        match self {

            Section::General => "general",

            Section::Collaborators => "collaborators",

            Section::Landing => "landing",

            Section::Checks => "checks",

            Section::PushProtection => "push-protection",

            Section::Pipelines => "flow",

            Section::Runs => "runs",

            Section::Gates => "gates",

            Section::Runners => "runners",

            Section::Variables => "variables",

            Section::Secrets => "secrets",

            Section::Coverage => "coverage",

            Section::Webhooks => "webhooks",

            Section::Assistants => "assistants",

            Section::GitMirror => "git-mirror",

            Section::Diffusion => "diffusion",

            Section::Storage => "storage",

            Section::Backup => "backup",

            Section::Advanced => "advanced",

        }

    }

    pub fn title(self) -> &'static str {

        match self {

            Section::General => "General",

            Section::Collaborators => "Collaborators",

            Section::Landing => "Landing rules",

            Section::Checks => "Required checks",

            Section::PushProtection => "Push protection",

            Section::Pipelines => "Pipelines",

            Section::Runs => "Runs & priority",

            Section::Gates => "Gates & agents",

            Section::Runners => "Runners",

            Section::Variables => "Variables",

            Section::Secrets => "Secrets",

            Section::Coverage => "Coverage",

            Section::Webhooks => "Webhooks",

            Section::Assistants => "AI assistants",

            Section::GitMirror => "Git mirror",

            Section::Diffusion => "Diffusion",

            Section::Storage => "Storage",

            Section::Backup => "Backup",

            Section::Advanced => "Advanced",

        }

    }

    pub fn parse(slug: &str) -> Option<Section> {

        GROUPS.iter().flat_map(|(_, pages)| pages.iter().copied()).find(|s| s.slug() == slug)

    }

    /// Whether only the repository's admins use it; its maintainers use

    /// the rest. The roles are those of each page's forms.

    fn admin_only(self) -> bool {

        matches!(

            self,

            Section::Collaborators

                | Section::Runners

                | Section::Variables

                | Section::Secrets

                | Section::Webhooks

                | Section::Assistants

                | Section::Storage

                | Section::Advanced

        )

    }

    /// Whether this viewer has the page: Storage only for a repository kept

    /// in a bucket.

    fn shown(self, role: Role, in_bucket: bool) -> bool {

        (!self.admin_only() || role == Role::Admin) && (self != Section::Storage || in_bucket)

    }

}

/// The sidebar a viewer sees: the groups with at least one page for them.

fn sidebar(role: Role, in_bucket: bool) -> Vec<(&'static str, Vec<Section>)> {

    GROUPS

        .iter()

        .map(|(group, pages)| (*group, pages.iter().copied().filter(|s| s.shown(role, in_bucket)).collect::<Vec<_>>()))

        .filter(|(_, pages)| !pages.is_empty())

        .collect()

}

/// Back to the page that holds a settings form, with what happened (#278).

fn back(row: &db::repos::RepoRow, section: Section, notice: Option<String>, error: Option<String>) -> Result<Response, Error> {

    let mut to = format!("/{}/{}/settings/{}", row.owner, row.name, section.slug());

    if let Some(n) = notice {

        to.push_str(&format!("?notice={}", super::settings::urlencode(&n)));

    } else if let Some(e) = error {

        to.push_str(&format!("?error={}", super::settings::urlencode(&e)));

    }

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

}

#[derive(Template)]

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

pub struct RepoSettingsPage {

    /// The page shown, and the sidebar's groups of pages.

    section: Section,

    nav: Vec<(&'static str, Vec<Section>)>,

    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,

    /// hub.toml's `[diffusion] follow` (#148).

    diffusion_site: String,

    flow_enabled: bool,

    site_admin: bool,

    /// Whether the repository or its owner has a runner of its own (#225).