//! Forks (hub spec §4): making one, listing them, and proposing from one
//! back to the repository it came from.

use super::settings::{csrf, require};
use super::{filters, lookup, Error, Page, RepoShell, Shell};
use crate::auth::{roles, 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 serde::Deserialize;

#[derive(Template)]
#[template(path = "fork_new.html")]
pub struct ForkPage {
    shell: Shell,
    repo: RepoShell,
    owners: Vec<String>,
    name: String,
    error: Option<String>,
}

pub async fn form(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<ForkPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
    let me = require(&viewer, &shell)?;
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let owners = super::repo_settings::owners_for(&app, &me.account).await;
    Ok(Page(ForkPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, owners, name, error: None }))
}

#[derive(Deserialize)]
pub struct ForkForm {
    #[serde(rename = "_csrf")]
    csrf_token: String,
    owner: String,
    name: String,
}

/// Anyone who can read a repository may fork it under an owner they may
/// create repositories for; the fork keeps the source's visibility.
pub async fn create(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
    Form(f): Form<ForkForm>,
) -> Result<Response, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);
    let me = require(&viewer, &shell)?;
    csrf(&viewer, &f.csrf_token, &shell)?;
    let (source, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let owners = super::repo_settings::owners_for(&app, &me.account).await;
    let page = |msg: &str| {
        Page(ForkPage {
            shell: shell.clone(),
            repo: RepoShell::new(&app, &row, "code").with_role(role),
            owners: owners.clone(),
            name: f.name.clone(),
            error: Some(msg.into()),
        })
        .into_response()
    };
    let Some(dest) = RepoName::new(f.owner.trim(), f.name.trim()) else {
        return Ok(page("A repository name is letters, digits, dots, dashes and underscores."));
    };
    if dest == source {
        return Ok(page("Pick another owner or name: a repository cannot be its own fork."));
    }
    if !roles::may_create_under(&app.db, &me.account, &dest.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {
        return Ok(page("You cannot create repositories under that owner."));
    }
    if db::repos::get(&app.db, &dest.owner, &dest.name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()
        || app.repos.exists(&dest)
    {
        return Ok(page("That repository exists."));
    }
    app.repos.fork(&source, &dest).await.map_err(|e| Error::from_repo(shell.clone(), e))?;
    let created = db::repos::create(&app.db, &dest.owner, &dest.name, &row.description, row.visibility())
        .await
        .map_err(|e| Error::from_db(shell.clone(), e))?;
    db::repos::set_forked_from(&app.db, created.id, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    accounts::audit(&app.db, Some(&me.account), "repo.forked", &dest.to_string(), &source.to_string()).await.ok();
    Ok(Redirect::to(&dest.url()).into_response())
}

#[derive(Template)]
#[template(path = "forks.html")]
pub struct ForksPage {
    shell: Shell,
    repo: RepoShell,
    forks: Vec<db::repos::RepoRow>,
}

pub async fn list(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, name)): Path<(String, String)>,
) -> Result<Page<ForksPage>, Error> {
    let shell = Shell::new(&app, &format!("/{owner}/{name}/forks"), &viewer);
    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;
    let all = db::repos::forks_of(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let forks = super::home::visible(&app, &shell, &viewer, all).await?;
    Ok(Page(ForksPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, forks }))
}

/// What the overview says about forks: where this one came from (when the
/// viewer may see it) and how many forks it has.
pub struct ForkInfo {
    pub upstream: Option<db::repos::RepoRow>,
    pub forks: usize,
}

pub async fn info(app: &Shared, shell: &Shell, viewer: &Viewer, row: &db::repos::RepoRow) -> ForkInfo {
    let upstream = match row.forked_from {
        Some(id) => match db::repos::get_by_id(&app.db, id).await {
            Ok(Some(up)) => super::home::visible(app, shell, viewer, vec![up]).await.ok().and_then(|mut v| v.pop()),
            _ => None,
        },
        None => None,
    };
    let forks = match db::repos::forks_of(&app.db, row.id).await {
        Ok(all) => super::home::visible(app, shell, viewer, all).await.map(|v| v.len()).unwrap_or(0),
        Err(_) => 0,
    };
    ForkInfo { upstream, forks }
}