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

}

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,

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

    #[serde(default)]

    storage: String,

    #[serde(flatten)]

    bucket: BucketForm,

}

/// 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 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 name.name.ends_with(crate::wiki::SUFFIX) {

        return Ok(fail("A name cannot end in .wiki: that is the address of a repository's wiki."));

    }

    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."));

    }

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

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

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

    }

    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())

}

/// 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).

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

    /// The repository's AI assistants and prompt (#97).

    assistants: super::assistants::Panel,

    /// The repository's Flow variables (#102).

    variables: super::variables::Panel,

    /// The repository's Flow secrets (#107).

    secrets: super::secrets::Panel,

    /// Where its data lives, when in a bucket (oxygenhub#96).

    storage: Option<crate::storage::Storage>,

    /// The coverage check's rules (#113).

    coverage: crate::coverage::Rules,

    /// Its owner's backup, when one is set up (docs/backups.md §5).

    backup_owner: Option<crate::backups::Setting>,

    /// Push protection (#268): the findings of recent refused pushes not

    /// yet allowed, and the fingerprints allowed.

    push_findings: Vec<db::push_protection::FindingRow>,

    secret_bypasses: Vec<db::push_protection::Bypass>,

    /// The history scan (#277): its progress, its open findings and those

    /// marked resolved, and whether the hub runs it at all.

    history_scan: Option<db::push_protection::ScanRow>,

    history_findings: Vec<db::push_protection::HistoryRow>,

    resolved_findings: Vec<db::push_protection::HistoryRow>,

    history_scan_on: bool,

}

impl RepoSettingsPage {

    fn backup_choices(&self) -> &'static [(&'static str, &'static str)] {

        crate::backups::REPO_CHOICES

    }

}

/// One settings page, or not found when the viewer's role does not have it.

async fn settings_page(

    app: &Shared,

    shell: Shell,

    row: db::repos::RepoRow,

    role: Role,

    section: Section,

    notice: Option<String>,

    error: Option<String>,

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

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

    if !section.shown(role, storage.is_some()) {

        return Err(Error::not_found(shell));

    }

    let nav = sidebar(role, storage.is_some());

    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 diffusion_site = app.config.diffusion.follow.clone();

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

    let site_admin = shell.is_admin;

    let own_runner = has_own_runner(app, &row).await.map_err(|e| Error::from_db(shell.clone(), e))?;

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

    let assistants = super::assistants::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let variables = super::variables::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let secrets = super::secrets::panel(app, &repo_assistants(&row)).await.map_err(|e| Error::from_db(shell.clone(), e))?;

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

    let backup_owner = crate::backups::setting(&app.db, &row.owner).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let push_findings = db::push_protection::recent(&app.db, row.id, 50).await.map_err(|e| Error::from_db(shell.clone(), e))?;

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

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

    let history_findings = db::push_protection::history(&app.db, row.id, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let resolved_findings = db::push_protection::resolved(&app.db, row.id, 50).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let history_scan_on = crate::history_scan::Budget::of(&app.config).is_some();

    Ok(Page(RepoSettingsPage {

        section,

        nav,

        push_findings,

        secret_bypasses,

        history_scan,

        history_findings,

        resolved_findings,

        history_scan_on,

        backup_owner,

        coverage,

        storage,

        assistants,

        variables,

        secrets,

        runners,

        runner_token: None,

        shell,

        repo,

        row,

        collaborators,

        teams,

        role,

        requirements,

        hooks,

        required_checks,

        flow_default,

        diffusion_site,

        flow_enabled,

        site_admin,

        own_runner,

        notice,

        error,

    }))

}

/// What a settings form did, carried to the page it redirects to.

#[derive(Deserialize, Default)]

pub struct Outcome {

    #[serde(default)]

    notice: Option<String>,

    #[serde(default)]

    error: Option<String>,

}

/// `GET /{owner}/{name}/settings`: the General page.

pub async fn settings(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<Outcome>,

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

    let path = format!("/{owner}/{name}/settings");

    show(&app, &viewer, &path, &owner, &name, Section::General, q).await

}

/// `GET /{owner}/{name}/settings/{page}` (#278): one page of the settings.

/// Some pages share their path with their form's `POST`, so the page is

/// the path's last segment.

pub async fn page(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(params): Path<std::collections::HashMap<String, String>>,

    uri: Uri,

    Query(q): Query<Outcome>,

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

    let (owner, name) = (params.get("owner").cloned().unwrap_or_default(), params.get("name").cloned().unwrap_or_default());

    let path = format!("/{owner}/{name}/settings");

    let slug = uri.path().rsplit('/').next().unwrap_or("");

    let Some(section) = Section::parse(slug) else {

        return Err(Error::not_found(Shell::new(&app, &path, &viewer)));