//! Projects (hub spec §8.2): boards of issues, proposals and notes across

//! the repositories of one person or organisation.

use super::settings::csrf;

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

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

use crate::db::{self, projects as pdb};

use crate::Shared;

use askama::Template;

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

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

use serde::Deserialize;

/// What a caller may do with an owner's projects.

pub struct Rights {

    /// Sees private projects.

    pub member: bool,

    /// Creates and changes projects.

    pub edit: bool,

}

/// Rights of `account` (anonymous when `None`) over `owner`'s projects;

/// `None` when there is no such person or organisation.

pub async fn rights_of(app: &Shared, account: Option<&db::accounts::Account>, owner: &str) -> sqlx::Result<Option<Rights>> {

    let admin = account.is_some_and(|a| a.is_admin);

    if let Some(a) = db::accounts::account_by_name(&app.db, owner).await? {

        let me = account.is_some_and(|v| v.id == a.id);

        return Ok(Some(Rights { member: me || admin, edit: me || admin }));

    }

    if let Some(o) = db::accounts::org_by_name(&app.db, owner).await? {

        let member = match account {

            Some(v) => db::accounts::org_role(&app.db, o.id, v.id).await?.is_some(),

            None => false,

        };

        return Ok(Some(Rights { member: member || admin, edit: member || admin }));

    }

    Ok(None)

}

async fn rights(app: &Shared, shell: &Shell, viewer: &Viewer, owner: &str) -> Result<Rights, Error> {

    rights_of(app, viewer.account(), owner)

        .await

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

        .ok_or_else(|| Error::not_found(shell.clone()))

}

#[derive(Template)]

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

pub struct ProjectsPage {

    shell: Shell,

    owner: String,

    projects: Vec<pdb::Project>,

    can_edit: bool,

    error: Option<String>,

}

pub async fn list(State(app): State<Shared>, viewer: Viewer, Path(owner): Path<String>) -> Result<Page<ProjectsPage>, Error> {

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

    let r = rights(&app, &shell, &viewer, &owner).await?;

    let projects = pdb::of_owner(&app.db, &owner)

        .await

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

        .into_iter()

        .filter(|p| p.public || r.member)

        .collect();

    Ok(Page(ProjectsPage { shell, owner, projects, can_edit: r.edit, error: None }))

}

#[derive(Deserialize)]

pub struct NewProjectForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    title: String,

    #[serde(default)]

    description: String,

    #[serde(default)]

    private: Option<String>,

}

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(owner): Path<String>,

    Form(f): Form<NewProjectForm>,

) -> Result<Response, Error> {

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

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

    let r = rights(&app, &shell, &viewer, &owner).await?;

    if !r.edit {

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

    }

    let title = f.title.trim();

    if title.is_empty() || title.len() > 100 {

        let projects = pdb::of_owner(&app.db, &owner).await.map_err(|e| Error::from_db(shell.clone(), e))?;

        return Ok(Page(ProjectsPage {

            shell,

            owner,

            projects,

            can_edit: true,

            error: Some("A project needs a title of up to 100 characters.".into()),

        })

        .into_response());

    }

    let p = pdb::create(&app.db, &owner, title, f.description.trim(), f.private.is_none())

        .await

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

    db::accounts::audit(&app.db, viewer.account(), "project.created", &format!("{owner}/{}", p.number), title).await.ok();

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

}

/// A card as the board shows it.

pub struct CardView {

    pub card: pdb::Card,

    /// `owner/name#N`, for issue and proposal cards.

    pub reference: String,

    pub url: String,

    pub title: String,

    /// `open`, `closed`, `landed`, `draft`… for issues and proposals.

    pub state: String,

}

pub struct ColumnView {

    pub column: pdb::Column,

    pub cards: Vec<CardView>,

}

#[derive(Template)]

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

pub struct BoardPage {

    shell: Shell,

    project: pdb::Project,

    columns: Vec<ColumnView>,

    /// The owner's repositories the viewer can read, for adding cards.

    repos: Vec<String>,

    /// Changes cards and columns (an open project).

    can_edit: bool,

    /// Changes the settings (to reopen a closed project too).

    can_manage: bool,

    notice: Option<String>,

    error: Option<String>,

}

async fn board(

    app: &Shared,

    shell: Shell,

    viewer: &Viewer,

    owner: &str,

    number: i64,

    notice: Option<String>,

    error: Option<String>,

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

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

    let r = rights(app, &shell, viewer, owner).await?;

    let project = pdb::get(&app.db, owner, number)

        .await

        .map_err(e)?

        .filter(|p| p.public || r.member)

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let (columns, repos) = board_columns(app, viewer.account(), owner, &project).await.map_err(e)?;

    let can_edit = r.edit && !project.closed;

    Ok(Page(BoardPage { shell, project, columns, repos, can_edit, can_manage: r.edit, notice, error }))

}

/// A project's columns with the cards `account` may see, and the owner's

/// repositories it can read (for adding cards).

pub async fn board_columns(

    app: &Shared,

    account: Option<&db::accounts::Account>,

    owner: &str,

    project: &pdb::Project,

) -> sqlx::Result<(Vec<ColumnView>, Vec<String>)> {

    let mut readable: std::collections::HashMap<i64, db::repos::RepoRow> = Default::default();

    for row in db::repos::list_by_owner(&app.db, owner).await? {

        let role = roles::role_for(&app.db, account, &row).await?;

        if roles::allows(role, Access::Read) {

            readable.insert(row.id, row);

        }

    }

    let cards = pdb::cards(&app.db, project.id).await?;

    let mut columns = Vec::new();

    for column in pdb::columns(&app.db, project.id).await? {

        let mut views = Vec::new();

        for card in cards.iter().filter(|c| c.column_id == column.id) {

            match (card.kind.as_str(), card.repo_id, card.number) {

                ("note", _, _) => views.push(CardView {

                    card: card.clone(),

                    reference: String::new(),

                    url: String::new(),

                    title: card.note.clone(),

                    state: String::new(),

                }),

                (kind, Some(rid), Some(n)) => {

                    // Cards of repositories the viewer cannot read are not shown at all.

                    let Some(row) = readable.get(&rid) else { continue };

                    let (title, state) = if kind == "issue" {

                        match db::issues::get(&app.db, rid, n).await? {

                            Some(i) => (i.title, i.state),

                            None => continue,

                        }

                    } else {

                        match db::proposals::get(&app.db, rid, n).await? {

                            Some(p) => (p.title, p.state),

                            None => continue,

                        }

                    };

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

                    views.push(CardView {

                        card: card.clone(),

                        reference: format!("{slug}#{n}"),

                        url: format!("/{slug}/{kind}/{n}"),

                        title,

                        state,

                    });

                }

                _ => {}

            }

        }

        columns.push(ColumnView { column, cards: views });

    }

    let mut repos: Vec<String> = readable.values().map(|r| r.name.clone()).collect();

    repos.sort();

    Ok((columns, repos))

}

pub async fn show(State(app): State<Shared>, viewer: Viewer, Path((owner, number)): Path<(String, i64)>) -> Result<Page<BoardPage>, Error> {

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

    board(&app, shell, &viewer, &owner, number, None, None).await

}

#[derive(Deserialize)]

pub struct BoardForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    action: String,

    #[serde(default)]

    card: Option<i64>,

    #[serde(default)]

    column: Option<i64>,

    #[serde(default)]

    name: String,

    /// `repo#12`, or `#12` with `repo`.

    #[serde(default)]

    reference: String,

    #[serde(default)]

    repo: String,

    #[serde(default)]

    note: String,

    #[serde(default)]

    title: String,

    #[serde(default)]

    description: String,

    #[serde(default)]

    private: Option<String>,

    #[serde(default)]

    closed: Option<String>,

}

/// `repo#12` or `#12` (with a repository chosen) to (repository, number).

/// `repo#12`, `#12` with `repo`, or `owner/repo#12` when `owner` is the

/// board's (the form the board itself shows, oxygenhub#118). `Err` says

/// what is wrong.

fn parse_reference(reference: &str, repo: &str, owner: &str) -> Result<(String, i64), String> {

    let bad = || "Name an issue or proposal as repo#12, or write a note.".to_string();

    let r = reference.trim();

    let (name, n) = r.split_once('#').ok_or_else(bad)?;

    let name = if name.is_empty() { repo.trim() } else { name.trim() };

    let name = match name.split_once('/') {

        Some((o, rest)) if o.eq_ignore_ascii_case(owner) => rest,

        Some((o, _)) => return Err(format!("This board holds only {owner}'s issues and proposals, not {o}'s.")),

        None => name,

    };

    let n: i64 = n.trim().parse().map_err(|_| bad())?;

    if name.is_empty() || n <= 0 || name.contains('/') {

        return Err(bad());

    }

    Ok((name.to_string(), n))

}

/// Add a note, or the issue or proposal `reference` names (`repo#12`, or

/// `#12` with `repo`), to a column. `Ok(Err(why))` for what the caller

/// should be told: an unknown repository or number, or a card already there.

#[allow(clippy::too_many_arguments)]

pub async fn add_card(

    app: &Shared,

    account: Option<&db::accounts::Account>,

    owner: &str,

    project_id: i64,

    column_id: i64,

    reference: &str,

    repo: &str,

    note: &str,

    actor: &str,

) -> sqlx::Result<Result<pdb::Card, String>> {

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

        let note: String = note.trim().chars().take(500).collect();

        pdb::add_card(

            &app.db,

            project_id,

            pdb::NewCard { column_id, kind: "note", repo_id: None, number: None, note: &note, added_by: actor },

        )

        .await?;

        return Ok(Ok(newest_card(app, project_id).await?));

    }

    let (repo, n) = match parse_reference(reference, repo, owner) {

        Ok(r) => r,

        Err(why) => return Ok(Err(why)),

    };

    let Some(row) = db::repos::get(&app.db, owner, &repo).await? else { return Ok(Err(format!("{owner} has no repository {repo}."))) };

    let role = roles::role_for(&app.db, account, &row).await?;

    let (issues, proposals) = db::issues::numbers(&app.db, row.id).await?;

    let kind = if issues.contains(&n) {

        "issue"

    } else if proposals.contains(&n) {

        "proposal"

    } else {

        return Ok(Err(format!("{repo} has no issue or proposal #{n}.")));

    };

    if !roles::allows(role, Access::Read) {

        return Ok(Err(format!("{repo} has no issue or proposal #{n}.")));

    }

    if !pdb::add_card(

        &app.db,

        project_id,

        pdb::NewCard { column_id, kind, repo_id: Some(row.id), number: Some(n), note: "", added_by: actor },

    )

    .await?

    {

        return Ok(Err(format!("{repo}#{n} is already on this project.")));

    }

    Ok(Ok(newest_card(app, project_id).await?))

}

async fn newest_card(app: &Shared, project_id: i64) -> sqlx::Result<pdb::Card> {

    sqlx::query_as("SELECT * FROM project_cards WHERE project_id = ? ORDER BY id DESC LIMIT 1").bind(project_id).fetch_one(&app.db).await

}

pub async fn act(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, number)): Path<(String, i64)>,

    Form(f): Form<BoardForm>,

) -> Result<Response, Error> {

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

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

    let r = rights(&app, &shell, &viewer, &owner).await?;

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

    let project = pdb::get(&app.db, &owner, number)

        .await

        .map_err(e)?

        .filter(|p| p.public || r.member)

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    if !r.edit {

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

    }

    if project.closed && !matches!(f.action.as_str(), "settings" | "delete") {

        return Ok(board(&app, shell, &viewer, &owner, number, None, Some("This project is closed; reopen it to change it.".into()))

            .await?

            .into_response());

    }

    let actor = viewer.account().map(|a| a.username.clone()).unwrap_or_default();

    let columns = pdb::columns(&app.db, project.id).await.map_err(e)?;

    let column = f.column.filter(|c| columns.iter().any(|x| x.id == *c)).or(columns.first().map(|c| c.id));

    let mut notice = None;

    let mut error = None;

    match f.action.as_str() {

        "add" => {

            let Some(column_id) = column else { return Err(Error::bad(shell, "no column")) };

            if let Err(msg) =

                add_card(&app, viewer.account(), &owner, project.id, column_id, &f.reference, &f.repo, &f.note, &actor).await.map_err(e)?

            {

                error = Some(msg);

            }

        }

        "move" => {

            if let (Some(card), Some(col)) = (f.card, f.column) {

                pdb::move_card(&app.db, project.id, card, col).await.map_err(e)?;

            }

        }

        "up" | "down" => {

            if let Some(card) = f.card {

                pdb::shift_card(&app.db, project.id, card, if f.action == "up" { -1 } else { 1 }).await.map_err(e)?;

            }

        }

        "remove" => {

            if let Some(card) = f.card {

                pdb::remove_card(&app.db, project.id, card).await.map_err(e)?;

            }

        }

        "add_column" => {

            let name = f.name.trim();

            if name.is_empty() || name.len() > 40 {

                error = Some("A column has a name of up to 40 characters.".into());

            } else {

                pdb::add_column(&app.db, project.id, name).await.map_err(e)?;

            }

        }

        "rename_column" => {

            if let (Some(col), name) = (f.column, f.name.trim()) {

                if !name.is_empty() && name.len() <= 40 {

                    pdb::rename_column(&app.db, project.id, col, name).await.map_err(e)?;

                }

            }

        }

        "left" | "right" => {

            if let Some(col) = f.column {

                pdb::shift_column(&app.db, project.id, col, if f.action == "left" { -1 } else { 1 }).await.map_err(e)?;

            }

        }

        "remove_column" => {

            if let Some(col) = f.column {

                if !pdb::remove_column(&app.db, project.id, col).await.map_err(e)? {

                    error = Some("A project keeps at least one column.".into());

                }

            }

        }

        "settings" => {

            let title = if f.title.trim().is_empty() { project.title.clone() } else { f.title.trim().chars().take(100).collect() };

            pdb::set(&app.db, project.id, &title, f.description.trim(), f.private.is_none(), f.closed.is_some()).await.map_err(e)?;

            notice = Some("Saved.".into());

        }

        "delete" => {

            pdb::delete(&app.db, project.id).await.map_err(e)?;

            db::accounts::audit(&app.db, viewer.account(), "project.deleted", &format!("{owner}/{number}"), &project.title).await.ok();

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

        }

        _ => return Err(Error::bad(shell, "unknown action")),

    }

    if notice.is_none() && error.is_none() {

        // Back to the board, so a reload does not repeat the action.

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

    }

    Ok(board(&app, shell, &viewer, &owner, number, notice, error).await?.into_response())

}

/// The projects an issue or proposal is on that the viewer may see, with

/// their column.

pub async fn placements_for(app: &Shared, viewer: &Viewer, repo: &db::repos::RepoRow, number: i64) -> Vec<(pdb::Project, String)> {

    let Ok(all) = pdb::placements(&app.db, repo.id, number).await else { return vec![] };

    let mut out = Vec::new();

    for (p, col) in all {

        let visible = p.public

            || viewer.is_admin()

            || match viewer.account() {

                Some(v) if v.username == p.owner => true,

                Some(v) => match db::accounts::org_by_name(&app.db, &p.owner).await.ok().flatten() {

                    Some(o) => db::accounts::org_role(&app.db, o.id, v.id).await.ok().flatten().is_some(),

                    None => false,

                },

                None => false,

            };

        if visible {

            out.push((p, col));

        }

    }

    out

}

#[cfg(test)]

mod tests {

    use super::parse_reference;

    #[test]

    fn references() {

        let p = |r: &str, repo: &str| parse_reference(r, repo, "andy").ok();

        assert_eq!(p("oxygen#12", ""), Some(("oxygen".into(), 12)));

        assert_eq!(p("#7", "hub"), Some(("hub".into(), 7)));

        assert_eq!(p(" hub # 3 ", ""), Some(("hub".into(), 3)));

        assert_eq!(p("#7", ""), None, "a repository is needed");