//! Issues, labels and milestones (hub spec §8).

use super::settings::{csrf, require};

use super::{filters, lookup, lookup_role, Error, Page, RepoShell, Shell};

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

use crate::db::{self, accounts, issues as idb, notify as ndb};

use crate::notify::{self, Event};

use crate::render::{self, refs::Numbers};

use crate::repos::view;

use crate::Shared;

use askama::Template;

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

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

use serde::Deserialize;

use std::collections::HashMap;

/// Markdown with cross references linked, for a repository; relative

/// links and images resolve against `reference` (the default bookmark for

/// issues and proposals, the tag for release notes).

pub async fn markdown(app: &Shared, row: &db::repos::RepoRow, reference: &str, text: &str) -> String {

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

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

    let linked = render::refs::link(text, &Numbers { repo_url: &repo_url, issues: &issues, proposals: &proposals });

    render::markdown::render(&linked, &format!("{repo_url}/file/{reference}/"), &format!("{repo_url}/raw/{reference}/"))

}

/// Re-index a thread for search: title, body and every comment.

pub async fn reindex(app: &Shared, repo_id: i64, issue: &idb::IssueRow) {

    let comments = idb::comments(&app.db, issue.id).await.unwrap_or_default();

    let text = std::iter::once(issue.body.clone()).chain(comments.into_iter().map(|c| c.body)).collect::<Vec<_>>().join("\n\n");

    ndb::index(&app.db, "issue", repo_id, issue.id, issue.number, &issue.title, &text).await.ok();

}

// ------------------------------------------------------------------ list

pub struct IssueLine {

    pub issue: idb::IssueRow,

    pub labels: Vec<idb::Label>,

    pub assignees: Vec<String>,

    pub milestone: Option<String>,

    pub comments: i64,

}

#[derive(Template)]

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

pub struct IssuesPage {

    shell: Shell,

    repo: RepoShell,

    rows: Vec<IssueLine>,

    state: String,

    q: String,

    counts: (usize, usize),

    sort: String,

    pager: super::Pager,

}

#[derive(Deserialize)]

pub struct ListQuery {

    state: Option<String>,

    q: Option<String>,

    sort: Option<String>,

    page: Option<usize>,

}

/// The list's sort orders: `newest` (pinned first, the default),

/// `oldest`, `updated`, `comments`.

pub const SORTS: &[(&str, &str)] =

    &[("newest", "newest"), ("oldest", "oldest"), ("updated", "recently updated"), ("comments", "most comments")];

/// `label:bug assignee:andy milestone:v1 state:closed words…`

struct Filter {

    state: String,

    labels: Vec<String>,

    assignees: Vec<String>,

    authors: Vec<String>,

    milestone: Option<String>,

    words: Vec<String>,

}

fn parse_filter(state: Option<String>, q: &str) -> Filter {

    let mut f = Filter {

        state: state.unwrap_or_else(|| "open".into()),

        labels: vec![],

        assignees: vec![],

        authors: vec![],

        milestone: None,

        words: vec![],

    };

    for tok in q.split_whitespace() {

        match tok.split_once(':') {

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

            Some(("assignee", v)) => f.assignees.push(v.to_lowercase()),

            Some(("author", v)) => f.authors.push(v.to_lowercase()),

            Some(("milestone", v)) => f.milestone = Some(v.to_lowercase()),

            Some(("state", v)) => f.state = v.to_string(),

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

        }

    }

    f

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<ListQuery>,

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

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

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

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

    let all = idb::list(&app.db, row.id).await.map_err(e)?;

    let counts = (all.iter().filter(|i| i.state == "open").count(), all.iter().filter(|i| i.state == "closed").count());

    let qtext = q.q.clone().unwrap_or_default();

    let f = parse_filter(q.state, &qtext);

    let mut labels_by: HashMap<i64, Vec<idb::Label>> = HashMap::new();

    for (id, l) in idb::labels_by_issue(&app.db, row.id).await.map_err(e)? {

        labels_by.entry(id).or_default().push(l);

    }

    let mut assignees_by: HashMap<i64, Vec<String>> = HashMap::new();

    for (id, u) in idb::assignees_by_issue(&app.db, row.id).await.map_err(e)? {

        assignees_by.entry(id).or_default().push(u);

    }

    let milestones: HashMap<i64, String> =

        idb::milestones(&app.db, row.id).await.map_err(e)?.into_iter().map(|m| (m.id, m.title)).collect();

    let mut rows = Vec::new();

    for i in all {

        let labels = labels_by.remove(&i.id).unwrap_or_default();

        let assignees = assignees_by.remove(&i.id).unwrap_or_default();

        let milestone = i.milestone_id.and_then(|m| milestones.get(&m).cloned());

        let keep = (f.state == "all" || i.state == f.state)

            && f.labels.iter().all(|l| labels.iter().any(|x| x.name.to_lowercase() == *l))

            && f.assignees.iter().all(|a| assignees.iter().any(|x| x.to_lowercase() == *a))

            && (f.authors.is_empty() || f.authors.contains(&i.author.to_lowercase()))

            && f.milestone.as_ref().is_none_or(|m| milestone.as_ref().is_some_and(|x| x.to_lowercase() == *m))

            && f.words.iter().all(|w| i.title.to_lowercase().contains(w) || i.body.to_lowercase().contains(w));

        if keep {

            let comments: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM issue_comments WHERE issue_id = ?")

                .bind(i.id)

                .fetch_one(&app.db)

                .await

                .map_err(e)?;

            rows.push(IssueLine { issue: i, labels, assignees, milestone, comments });

        }

    }

    let sort = q.sort.filter(|s| SORTS.iter().any(|(k, _)| k == s)).unwrap_or_else(|| "newest".into());

    match sort.as_str() {

        "oldest" => rows.sort_by_key(|r| r.issue.number),

        "updated" => rows.sort_by_key(|r| std::cmp::Reverse(r.issue.updated_ms)),

        "comments" => rows.sort_by_key(|r| (std::cmp::Reverse(r.comments), std::cmp::Reverse(r.issue.number))),

        _ => {}

    }

    let pager = super::Pager::new(rows.len(), q.page, &[("state", &f.state), ("q", &qtext), ("sort", &sort)]);

    let rows = pager.slice(rows);

    Ok(Page(IssuesPage {

        shell,

        repo: RepoShell::new(&app, &row, "issues").with_role(role),

        rows,

        state: f.state,

        q: qtext,

        counts,

        sort,

        pager,

    }))

}

// ------------------------------------------------------------------- new

#[derive(Template)]

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

pub struct NewIssuePage {

    shell: Shell,

    repo: RepoShell,

    templates: Vec<(String, String)>,

    template: String,

    error: Option<String>,

}

#[derive(Deserialize)]

pub struct NewQuery {

    template: Option<String>,

}

/// `.oxyhub/ISSUE_TEMPLATE/*.md` in the default bookmark's state.

async fn issue_templates(app: &Shared, repo: &crate::repos::RepoName, default: &str) -> Vec<(String, String)> {

    let default = default.to_string();

    app.repos

        .read(repo, move |r, cache| {

            let Ok(target) = view::resolve(r, cache, &default) else { return Ok(vec![]) };

            let loaded = cache.load(r, &target.heads)?;

            let mut out = Vec::new();

            for (path, f) in &loaded.snapshot.files {

                if let Some(rest) = path.strip_prefix(".oxyhub/ISSUE_TEMPLATE/") {

                    if let (Some(name), oxy_core::state::FileContent::Text { bytes, .. }) = (rest.strip_suffix(".md"), &f.content) {

                        out.push((name.to_string(), String::from_utf8_lossy(bytes).into_owned()));

                    }

                }

            }

            Ok(out)

        })

        .await

        .unwrap_or_default()

}

pub async fn new_form(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<NewQuery>,

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

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

    require(&viewer, &shell)?;

    let (repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let templates = issue_templates(&app, &repo, &row.default_bookmark).await;

    let template = match q.template.as_deref() {

        Some("blank") => " ".into(),

        Some(t) => templates.iter().find(|(n, _)| n == t).map(|(_, b)| b.clone()).unwrap_or_default(),

        None if templates.is_empty() => " ".into(),

        None => String::new(),

    };

    Ok(Page(NewIssuePage { shell, repo: RepoShell::new(&app, &row, "issues").with_role(role), templates, template, error: None }))

}

#[derive(Deserialize)]

pub struct NewIssueForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    title: String,

    #[serde(default)]

    body: String,

}

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<NewIssueForm>,

) -> Result<Response, Error> {

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

    let me = require(&viewer, &shell)?;

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

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    super::writable(&row, &shell)?;

    if f.title.trim().is_empty() {

        return Ok(Page(NewIssuePage {

            shell,

            repo: RepoShell::new(&app, &row, "issues").with_role(role),

            templates: vec![],

            template: f.body,

            error: Some("Give the issue a title.".into()),

        })

        .into_response());

    }

    let issue = idb::create(

        &app.db,

        idb::NewIssue {

            repo_id: row.id,

            title: f.title.trim(),

            body: f.body.trim(),

            author_id: Some(me.account.id),

            author: &me.account.username,

        },

    )

    .await

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

    idb::add_event(&app.db, issue.id, &me.account.username, "opened", "").await.ok();

    reindex(&app, row.id, &issue).await;

    let url = format!("/{owner}/{name}/issue/{}", issue.number);

    notify::deliver(

        &app,

        Event {

            kind: "issue.opened",

            title: format!("{owner}/{name}#{}: {}", issue.number, issue.title),

            url: url.clone(),

            actor: &me.account,

            repo_id: row.id,

            thread: Some(("issue", issue.id)),

            mention_text: &f.body,

            direct: vec![],

        },

    )

    .await;

    crate::hooks::emit(

        &app,

        &row,

        "issue.opened",

        &me.account.username,

        serde_json::json!({ "issue": { "number": issue.number, "title": issue.title, "body": issue.body } }),

    )

    .await;

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

}

// ---------------------------------------------------------------- detail

pub enum Item {

    Comment(idb::IssueComment, String),

    Event(idb::IssueEvent),

}

#[derive(Template)]

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

pub struct IssuePage {

    shell: Shell,

    repo: RepoShell,

    i: idb::IssueRow,

    body_html: String,

    timeline: Vec<Item>,

    comments: Vec<idb::IssueComment>,

    labels: Vec<idb::Label>,

    all_labels: Vec<idb::Label>,

    assignees: Vec<String>,

    /// Who it can be assigned to, for triagers' menu (oxygenhub#82).

    assignable: Vec<String>,

    milestone: Option<idb::Milestone>,

    milestones: Vec<(idb::Milestone, bool)>,

    subscribed: bool,

    can_edit: bool,

    can_triage: bool,

    /// Projects this issue is on that the viewer may see, with the column.

    projects: Vec<(crate::db::projects::Project, String)>,

    /// Proposals whose description closes it.

    closed_by: Vec<super::chain::Link>,

    /// Projects the viewer may add it to.

    project_choices: Option<Vec<crate::db::projects::Project>>,

    notice: Option<String>,

    error: Option<String>,

}

/// The page assembler every action ends in.

#[allow(clippy::too_many_arguments)]

async fn detail(

    app: &Shared,

    shell: Shell,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    number: i64,

    notice: Option<String>,

    error: Option<String>,

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

    let (_, row, role) = lookup(app, &shell, viewer, owner, name).await?;

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

    let i = idb::get(&app.db, row.id, number).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let body_html = markdown(app, &row, &row.default_bookmark, &i.body).await;

    let comments = idb::comments(&app.db, i.id).await.map_err(e)?;

    let events = idb::events(&app.db, i.id).await.map_err(e)?;

    let mut timeline: Vec<(i64, Item)> = Vec::new();

    for c in &comments {

        timeline.push((c.created_ms, Item::Comment(c.clone(), markdown(app, &row, &row.default_bookmark, &c.body).await)));

    }

    for ev in events {

        if ev.event != "opened" {

            timeline.push((ev.at_ms, Item::Event(ev)));

        }

    }

    timeline.sort_by_key(|(t, _)| *t);

    let labels = idb::issue_labels(&app.db, i.id).await.map_err(e)?;

    let all_labels = idb::labels(&app.db, row.id).await.map_err(e)?;

    let assignees = idb::assignees(&app.db, i.id).await.map_err(e)?;

    let milestones: Vec<(idb::Milestone, bool)> = idb::milestones(&app.db, row.id)

        .await

        .map_err(e)?

        .into_iter()

        .map(|m| {

            let sel = i.milestone_id == Some(m.id);

            (m, sel)

        })

        .collect();

    let milestone = match i.milestone_id {

        Some(id) => idb::milestone(&app.db, id).await.map_err(e)?,

        None => None,

    };

    let me = viewer.account();

    let subscribed = match me {

        Some(a) => ndb::subscribed(&app.db, a.id, "issue", i.id).await.map_err(e)?,

        None => false,

    };

    let can_triage = role >= Role::Triage;

    let can_edit = me.is_some_and(|a| Some(a.id) == i.author_id) || can_triage;

    let projects = super::projects::placements_for(app, viewer, &row, i.number).await;

    let closed_by = super::chain::proposals_closing(app, &row, i.number).await;

    let project_choices = super::projects::project_choices(app, viewer, &row, &projects).await;

    let mut assignable = if can_triage { accounts::assignable(&app.db, row.id, &row.owner).await.map_err(e)? } else { Vec::new() };

    for a in &assignees {

        if !assignable.iter().any(|x| x.eq_ignore_ascii_case(a)) {

            assignable.push(a.clone());

        }

    }

    Ok(Page(IssuePage {

        shell,

        repo: RepoShell::new(app, &row, "issues").with_role(role),

        i,

        closed_by,

        project_choices,

        body_html,

        timeline: timeline.into_iter().map(|(_, it)| it).collect(),

        comments,

        labels,

        all_labels,

        assignees,

        assignable,

        milestone,

        milestones,

        subscribed,

        can_edit,

        can_triage,

        projects,

        notice,

        error,

    }))

}

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

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

) -> Result<Response, Error> {

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

    // A number that belongs to a proposal goes there (shared number space).

    let (_, row, _) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    if idb::get(&app.db, row.id, number).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_none()

        && db::proposals::get(&app.db, row.id, number).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()

    {

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

    }

    Ok(detail(&app, shell, &viewer, &owner, &name, number, None, None).await?.into_response())

}

// ---------------------------------------------------------------- actions

async fn issue_for(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    number: i64,

    access: Access,

) -> Result<(db::repos::RepoRow, idb::IssueRow, Role), Error> {

    let (_, row, role) = lookup_role(app, shell, viewer, owner, name, access).await?;

    let i = idb::get(&app.db, row.id, number)

        .await

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

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

    Ok((row, i, role))

}

#[derive(Deserialize)]

pub struct CommentForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    body: String,

    #[serde(default)]

    close: Option<String>,

    #[serde(default)]

    reopen: Option<String>,

}

pub async fn comment(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Form(f): Form<CommentForm>,

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

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

    let me = require(&viewer, &shell)?;

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

    let (row, i, role) = issue_for(&app, &shell, &viewer, &owner, &name, number, Access::Read).await?;

    if i.locked && role < Role::Triage {

        return detail(&app, shell, &viewer, &owner, &name, number, None, Some("This issue is locked.".into())).await;

    }

    if f.body.trim().is_empty() {

        return detail(&app, shell, &viewer, &owner, &name, number, None, Some("An empty comment says nothing.".into())).await;

    }

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