//! 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, issues as idb, projects as pdb};

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, Query, 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,

    /// The projects shown: open or closed as `closed` says, matching `q`.

    projects: Vec<pdb::Project>,

    can_edit: bool,

    error: Option<String>,

    /// On your own page, the organisations you belong to: their boards

    /// are one click away, and where a board for one is made (#119).

    orgs: Vec<String>,

    /// The title filter, and whether the closed ones are shown (#124).

    q: String,

    closed: bool,

    open_count: usize,

    closed_count: usize,

}

impl ProjectsPage {

    /// The page for `all` the projects the viewer may see: counted open

    /// and closed among those matching `q`, then the ones asked for.

    #[allow(clippy::too_many_arguments)]

    fn build(

        shell: Shell,

        owner: String,

        all: Vec<pdb::Project>,

        can_edit: bool,

        error: Option<String>,

        orgs: Vec<String>,

        q: Option<String>,

        closed: bool,

    ) -> ProjectsPage {

        let q = q.unwrap_or_default().trim().to_string();

        let needle = q.to_lowercase();

        let matching: Vec<pdb::Project> = all

            .into_iter()

            .filter(|p| needle.is_empty() || p.title.to_lowercase().contains(&needle) || p.description.to_lowercase().contains(&needle))

            .collect();

        let closed_count = matching.iter().filter(|p| p.closed).count();

        let open_count = matching.len() - closed_count;

        let projects = matching.into_iter().filter(|p| p.closed == closed).collect();

        ProjectsPage { shell, owner, projects, can_edit, error, orgs, q, closed, open_count, closed_count }

    }

}

/// `?q=TEXT&state=open|closed` on the Projects page (#124).

#[derive(Deserialize, Default)]

pub struct ProjectsQuery {

    #[serde(default)]

    q: Option<String>,

    #[serde(default)]

    state: Option<String>,

}

/// The organisations the viewer belongs to, when `owner` is the viewer.

async fn own_orgs(app: &Shared, viewer: &Viewer, owner: &str) -> Vec<String> {

    match viewer.account() {

        Some(a) if a.username == owner => {

            crate::db::accounts::orgs_of(&app.db, a.id).await.map(|v| v.into_iter().map(|(o, _)| o.name).collect()).unwrap_or_default()

        }

        _ => vec![],

    }

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

    Path(owner): Path<String>,

    Query(query): Query<ProjectsQuery>,

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

    let orgs = own_orgs(&app, &viewer, &owner).await;

    let closed = query.state.as_deref() == Some("closed");

    Ok(Page(ProjectsPage::build(shell, owner, projects, r.edit, None, orgs, query.q, closed)))

}

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

        let orgs = own_orgs(&app, &viewer, &owner).await;

        return Ok(Page(ProjectsPage::build(

            shell,

            owner,

            projects,

            true,

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

            orgs,

            None,

            false,

        ))

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

#[derive(Clone)]

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,

    /// The issue's or proposal's labels, and an issue's assignees (#293).

    pub labels: Vec<idb::Label>,

    pub assignees: Vec<String>,

    /// Its repository's name, its milestone's title, and when the issue or

    /// proposal was opened (a note: when it was added), for the filter's

    /// `repo:`, `milestone:` and `age:` and for lanes (#361).

    pub repo: String,

    pub milestone: String,

    pub opened_ms: i64,

}

#[derive(Clone)]

pub struct ColumnView {

    pub column: pdb::Column,

    pub cards: Vec<CardView>,

    /// Cards the page leaves out (#293): the oldest of a long column, or

    /// those a filter does not match; `total` is how many it holds.

    pub hidden: usize,

    pub total: usize,

    /// Its archived cards (#293), shown on the archive view.

    pub archived: usize,

    /// Its cards are all finished work (a Done column): its note says

    /// they are archived after a fortnight unless it says otherwise.

    pub finished: bool,

    /// More cards than its work-in-progress limit (#361).

    pub over_wip: bool,

    /// Done cards that reached it before the open iteration began, left

    /// out: the board shows this iteration's done work (#361).

    pub before_iteration: usize,

}

/// A column longer than this shows its newest cards only, with "show all"

/// (#293): a board's Done column otherwise grows without end.

pub const COLUMN_SHOWN: usize = 30;

/// How the board page shows its cards (#293).

#[derive(Deserialize, Default, Clone)]

pub struct BoardQuery {

    /// The column shown whole.

    #[serde(default)]

    all: Option<i64>,

    /// Only cards whose title or reference holds these words, and with

    /// `label:NAME`, `assignee:NAME` or `state:STATE` as the issue list takes.

    #[serde(default)]

    q: Option<String>,

    /// Only cards in this state (`open`, `closed`, `landed`…).

    #[serde(default)]

    state: Option<String>,

    /// The archived cards instead (`?archived=1`).

    #[serde(default)]

    archived: Option<String>,

    /// A past iteration: the cards archived under it, and its burn-up (#343).

    #[serde(default)]

    iteration: Option<i64>,

    /// A saved view, by name (#361): its layout, filter, lanes and sort;

    /// what the address says besides wins.

    #[serde(default)]

    pub view: Option<String>,

    /// `board` (the default) or `table`.

    #[serde(default)]

    pub layout: Option<String>,

    /// Swimlanes or groups: `repo`, `assignee`, `label`, `milestone`.

    #[serde(default)]

    pub lane: Option<String>,

    /// The table's order (`title`, `reference`, `state`, `column`, `age`;

    /// `-` first to reverse).

    #[serde(default)]

    pub sort: Option<String>,

    /// Compact cards: title, reference, avatars, labels as dots.

    #[serde(default)]

    pub compact: Option<String>,

    /// The table's page, from 1.

    #[serde(default)]

    pub page: Option<usize>,

}

impl BoardQuery {

    /// This query over the saved view it names (#361): what the address

    /// gives wins, the view fills the rest.

    pub fn over(&self, saved: Option<&pdb::View>) -> BoardQuery {

        let mut q = self.clone();

        if let Some(v) = saved {

            let fill = |x: &mut Option<String>, from: &str| {

                if x.is_none() && !from.is_empty() {

                    *x = Some(from.to_string());

                }

            };

            fill(&mut q.q, &v.q);

            fill(&mut q.layout, &v.layout);

            fill(&mut q.lane, &v.lane);

            fill(&mut q.sort, &v.sort);

        }

        q

    }

    pub fn layout(&self) -> &str {

        match self.layout.as_deref() {

            Some("table") => "table",

            _ => "board",

        }

    }

    pub fn lane(&self) -> &str {

        self.lane.as_deref().filter(|l| matches!(*l, "repo" | "assignee" | "label" | "milestone")).unwrap_or("")

    }

    fn compact(&self) -> bool {

        self.compact.as_deref().is_some_and(|c| !c.is_empty() && c != "0")

    }

    fn text(&self) -> String {

        self.q.as_deref().map(str::trim).unwrap_or("").to_string()

    }

    fn state(&self) -> String {

        self.state.as_deref().map(str::trim).unwrap_or("").to_ascii_lowercase()

    }

    fn archived(&self) -> bool {

        self.archived.as_deref().is_some_and(|a| !a.is_empty() && a != "0")

    }

}

/// The board filter's `label:`, `assignee:` and `state:` terms, and its words.

#[derive(Default)]

pub struct CardFilter {

    labels: Vec<String>,

    assignees: Vec<String>,

    state: String,

    words: Vec<String>,

    /// `repo:NAME`, `milestone:TITLE` (#361).

    repos: Vec<String>,

    milestones: Vec<String>,

    /// `is:open` (open or draft) or `is:closed` (closed or landed).

    is: String,

    /// `age:>14d` and `age:<7d`: opened more than, or less than, so many

    /// days ago.

    older_than_days: Option<i64>,

    newer_than_days: Option<i64>,

}

impl CardFilter {

    fn of(view: &BoardQuery) -> CardFilter {

        let mut f = CardFilter::parse(&view.text());

        if f.state.is_empty() {

            f.state = view.state();

        }

        f

    }

    /// The filter bar's text (#361): words, and `label:`, `assignee:`,

    /// `state:`, `repo:`, `milestone:`, `is:open|closed` and `age:>Nd` or

    /// `age:<Nd`. A value with spaces takes quotes: `milestone:"Release 1"`.

    pub fn parse(text: &str) -> CardFilter {

        let mut f = CardFilter::default();

        for tok in tokens(text) {

            match tok.split_once(':') {

                Some(("label", v)) if !v.is_empty() => f.labels.push(v.to_lowercase()),

                Some(("assignee", v)) if !v.is_empty() => f.assignees.push(v.trim_start_matches('@').to_lowercase()),

                Some(("state", v)) if !v.is_empty() => f.state = v.to_lowercase(),

                Some(("repo", v)) if !v.is_empty() => f.repos.push(v.rsplit('/').next().unwrap_or(v).to_lowercase()),

                Some(("milestone", v)) if !v.is_empty() => f.milestones.push(v.to_lowercase()),

                Some(("is", v)) if matches!(v, "open" | "closed") => f.is = v.to_string(),

                Some(("age", v)) if age_days(v).is_some() => match age_days(v) {

                    Some((true, d)) => f.older_than_days = Some(d),

                    Some((false, d)) => f.newer_than_days = Some(d),

                    None => {}

                },

                _ => f.words.push(tok.to_lowercase()),

            }

        }

        f

    }

    pub fn is_empty(&self) -> bool {

        self.labels.is_empty()

            && self.assignees.is_empty()

            && self.state.is_empty()

            && self.words.is_empty()

            && self.repos.is_empty()

            && self.milestones.is_empty()

            && self.is.is_empty()

            && self.older_than_days.is_none()

            && self.newer_than_days.is_none()

    }

    /// Every term holds: each word in the title or reference, each label

    /// and assignee among the card's, its state, repository, milestone and

    /// age.

    pub fn keeps(&self, c: &CardView, now: i64) -> bool {

        let (title, reference) = (c.title.to_lowercase(), c.reference.to_lowercase());

        let age_days = (now - c.opened_ms) / DAY_MS;

        self.words.iter().all(|w| title.contains(w) || reference.contains(w))

            && self.labels.iter().all(|l| c.labels.iter().any(|x| x.name.eq_ignore_ascii_case(l)))

            && self.assignees.iter().all(|a| c.assignees.iter().any(|x| x.eq_ignore_ascii_case(a)))

            && (self.state.is_empty() || c.state.eq_ignore_ascii_case(&self.state))

            && self.repos.iter().all(|r| c.repo.eq_ignore_ascii_case(r))

            && self.milestones.iter().all(|m| c.milestone.eq_ignore_ascii_case(m))

            && match self.is.as_str() {

                "open" => matches!(c.state.as_str(), "open" | "draft"),

                "closed" => matches!(c.state.as_str(), "closed" | "landed"),

                _ => true,

            }

            && self.older_than_days.is_none_or(|d| age_days > d)

            && self.newer_than_days.is_none_or(|d| age_days < d)

    }

}

/// The filter bar's words, a quoted value kept whole (`milestone:"Release 1"`).

fn tokens(text: &str) -> Vec<String> {

    let mut out = Vec::new();

    let mut cur = String::new();

    let mut quoted = false;

    for ch in text.chars() {

        match ch {

            '"' => quoted = !quoted,

            c if c.is_whitespace() && !quoted => {

                if !cur.is_empty() {

                    out.push(std::mem::take(&mut cur));

                }

            }

            c => cur.push(c),

        }

    }

    if !cur.is_empty() {

        out.push(cur);

    }

    out

}

/// `>14d` (older than 14 days: `(true, 14)`), `<7d` (newer: `(false, 7)`);

/// the `d` may be left off.

fn age_days(v: &str) -> Option<(bool, i64)> {

    let (older, rest) = match v.as_bytes().first()? {

        b'>' => (true, &v[1..]),

        b'<' => (false, &v[1..]),

        _ => return None,

    };

    let n: i64 = rest.trim_end_matches('d').parse().ok()?;

    (n >= 0).then_some((older, n))

}

/// Filter and cut the columns as `view` says. With an iteration open,

/// the Done column `done` shows the cards that reached it since the

/// iteration began (#361); the rest are counted.

fn shape(columns: &mut [ColumnView], view: &BoardQuery, now: i64, done: Option<i64>, since: Option<i64>) {

    let filter = CardFilter::of(view);

    for col in columns.iter_mut() {

        col.total = col.cards.len();

        if let (Some(d), Some(since), false) = (done, since, view.archived() || view.iteration.is_some()) {

            if col.column.id == d {

                let before = col.cards.len();

                col.cards.retain(|c| c.card.moved_ms >= since);

                col.before_iteration = before - col.cards.len();

                col.total = col.cards.len();

            }

        }

        col.over_wip = col.column.wip_limit.is_some_and(|w| w >= 0 && col.total as i64 > w);

        if !filter.is_empty() {

            col.cards.retain(|c| filter.keeps(c, now));

        } else if col.cards.len() > COLUMN_SHOWN && view.all != Some(col.column.id) && !view.archived() && view.iteration.is_none() {

            // Cards join a column at its end: the newest are the last.

            let cut = col.cards.len() - COLUMN_SHOWN;

            col.cards.drain(..cut);

        }

        col.hidden = col.total - col.cards.len();

    }

}

/// A swimlane (#361): the board's columns with the cards of one

/// repository, assignee, label or milestone.

pub struct LaneView {

    pub name: String,

    pub columns: Vec<ColumnView>,

    pub count: usize,

}

/// The lanes a card belongs to under `lane`: one, or one per assignee or

/// label; those without one share a lane named for it.

fn lanes_of(c: &CardView, lane: &str) -> Vec<String> {

    let many = |v: Vec<String>, none: &str| if v.is_empty() { vec![none.to_string()] } else { v };

    match lane {

        "repo" => vec![if c.repo.is_empty() { "(notes)".into() } else { c.repo.clone() }],

        "assignee" => many(c.assignees.iter().map(|a| format!("@{a}")).collect(), "(nobody)"),