//! The inbox, notification preferences and search (hub spec §10, §11).

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

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

use crate::auth::Viewer;

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

use crate::Shared;

use askama::Template;

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

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

use hub_api::Visibility;

use serde::Deserialize;

#[derive(Template)]

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

pub struct InboxPage {

    shell: Shell,

    threads: Vec<ndb::Thread>,

    unread: i64,

    email_on: bool,

    notice: Option<String>,

    q: InboxQuery,

    /// Kind families and repositories among the threads in the inbox, with counts.

    kinds: Vec<(String, usize)>,

    repos: Vec<(String, usize)>,

}

/// `?view=unread|done&reason=participating|watching&kind=issue&repo=owner/name`.

#[derive(Clone, Debug, Default, Deserialize)]

pub struct InboxQuery {

    #[serde(default)]

    pub view: String,

    #[serde(default)]

    pub reason: String,

    #[serde(default)]

    pub kind: String,

    #[serde(default)]

    pub repo: String,

}

impl InboxQuery {

    /// This query with one key changed, as a URL (empty values drop out).

    pub fn with(&self, key: &str, value: &str) -> String {

        let mut q = self.clone();

        match key {

            "view" => q.view = value.into(),

            "reason" => q.reason = value.into(),

            "kind" => q.kind = value.into(),

            "repo" => q.repo = value.into(),

            _ => {}

        }

        let parts: Vec<String> = [("view", &q.view), ("reason", &q.reason), ("kind", &q.kind), ("repo", &q.repo)]

            .iter()

            .filter(|(_, v)| !v.is_empty())

            .map(|(k, v)| format!("{k}={}", super::settings::urlencode(v)))

            .collect();

        if parts.is_empty() {

            "/notifications".into()

        } else {

            format!("/notifications?{}", parts.join("&"))

        }

    }

    /// This query as it is, for forms that come back to it.

    pub fn here(&self) -> String {

        self.with("", "")

    }

}

/// `issue.closed` → `issue`.

fn family(kind: &str) -> &str {

    kind.split('.').next().unwrap_or(kind)

}

async fn inbox_page(

    app: &Shared,

    shell: Shell,

    me: &accounts::Account,

    q: InboxQuery,

    notice: Option<String>,

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

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

    let repo_id = match q.repo.split_once('/') {

        Some((o, n)) => db::repos::get(&app.db, o, n).await.map_err(e)?.map(|r| r.id).or(Some(-1)),

        None => None,

    };

    let filter = ndb::Filter {

        done: q.view == "done",

        unread_only: q.view == "unread",

        reason: (!q.reason.is_empty()).then(|| q.reason.clone()),

        kind: (!q.kind.is_empty()).then(|| q.kind.clone()),

        repo_id,

    };

    let threads = ndb::threads(&app.db, me.id, &filter, 200).await.map_err(e)?;

    // Facets over the whole inbox, so the choices do not vanish as you pick.

    let all = ndb::threads(&app.db, me.id, &ndb::Filter { done: filter.done, ..Default::default() }, 1000).await.map_err(e)?;

    let mut kinds: std::collections::BTreeMap<String, usize> = Default::default();

    let mut repos: std::collections::BTreeMap<String, usize> = Default::default();

    for t in &all {

        *kinds.entry(family(&t.kind).to_string()).or_default() += 1;

        if let Some(r) = &t.repo {

            *repos.entry(r.clone()).or_default() += 1;

        }

    }

    let unread = ndb::unread(&app.db, me.id).await.map_err(e)?;

    let fresh = accounts::account_by_id(&app.db, me.id).await.ok().flatten();

    Ok(Page(InboxPage {

        shell,

        threads,

        unread,

        email_on: fresh.map(|a| a.email_notifications).unwrap_or(false),

        notice,

        q,

        kinds: kinds.into_iter().collect(),

        repos: repos.into_iter().collect(),

    }))

}

pub async fn inbox(State(app): State<Shared>, viewer: Viewer, Query(q): Query<InboxQuery>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

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

    inbox_page(&app, shell, &me.account, q, None).await

}

#[derive(Deserialize)]

pub struct ReadForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    id: Option<i64>,

}

pub async fn mark_read(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ReadForm>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

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

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

    ndb::mark_read(&app.db, me.account.id, f.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    inbox_page(&app, shell, &me.account, InboxQuery::default(), None).await

}

#[derive(Deserialize)]

pub struct ThreadForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    thread: String,

    /// `read`, `unread`, `done` or `undone`.

    action: String,

    /// Where to go back to: the inbox with its filters.

    #[serde(default)]

    back: String,

}

/// `POST /notifications/thread`.

pub async fn thread(State(app): State<Shared>, viewer: Viewer, Form(f): Form<ThreadForm>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

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

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

    let (read, done) = match f.action.as_str() {

        "read" => (Some(true), None),

        "unread" => (Some(false), None),

        "done" => (None, Some(true)),

        "undone" => (None, Some(false)),

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

    };

    ndb::set_thread(&app.db, me.account.id, &f.thread, read, done).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let back = if f.back.starts_with("/notifications") { f.back } else { "/notifications".into() };

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

}

/// `GET /notifications/open/{id}`: mark the thread read and go to it.

pub async fn open(State(app): State<Shared>, viewer: Viewer, axum::extract::Path(id): axum::extract::Path<i64>) -> Result<Response, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

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

    let n = ndb::get(&app.db, me.account.id, id)

        .await

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

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

    ndb::set_thread(&app.db, me.account.id, &n.thread, Some(true), None).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    // Only local pages: a notification's URL is a path on this hub.

    let to = if n.url.starts_with('/') && !n.url.starts_with("//") { n.url } else { "/notifications".into() };

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

}

#[derive(Deserialize)]

pub struct PrefsForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    email: Option<String>,

}

pub async fn prefs(State(app): State<Shared>, viewer: Viewer, Form(f): Form<PrefsForm>) -> Result<Page<InboxPage>, Error> {

    let shell = Shell::new(&app, "/notifications", &viewer);

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

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

    let key = if me.account.unsubscribe_key.is_empty() { crate::auth::random_hex(16) } else { me.account.unsubscribe_key.clone() };

    sqlx::query("UPDATE accounts SET email_notifications = ?, unsubscribe_key = ? WHERE id = ?")

        .bind(f.email.is_some())

        .bind(&key)

        .bind(me.account.id)

        .execute(&app.db)

        .await

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

    inbox_page(

        &app,

        shell,

        &me.account,

        InboxQuery::default(),

        Some(if f.email.is_some() { "Email notifications are on.".into() } else { "Email notifications are off.".into() }),

    )

    .await

}

#[derive(Deserialize)]

pub struct UnsubQuery {

    unsubscribe: Option<String>,

}

/// The one-click link in every email: no session needed, the key is the proof.

pub async fn unsubscribe(State(app): State<Shared>, Query(q): Query<UnsubQuery>) -> Response {

    if let Some(key) = q.unsubscribe.filter(|k| k.len() >= 16) {

        sqlx::query("UPDATE accounts SET email_notifications = 0 WHERE unsubscribe_key = ?").bind(key).execute(&app.db).await.ok();

        return (axum::http::StatusCode::OK, "Email notifications are off for that account.").into_response();

    }

    Redirect::to("/notifications").into_response()

}

// ------------------------------------------------------------------ search

pub struct HitView {

    pub kind: String,

    pub slug: String,

    pub number: i64,

    pub title: String,

    pub snippet: String,

    pub url: String,

}

#[derive(Template)]

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

pub struct SearchPage {

    shell: Shell,

    q: String,

    repos: Vec<db::repos::RepoRow>,

    accounts: Vec<String>,

    hits: Vec<HitView>,

}

#[derive(Deserialize)]

pub struct SearchQuery {

    q: Option<String>,

}

pub async fn search(State(app): State<Shared>, viewer: Viewer, Query(q): Query<SearchQuery>) -> Result<Page<SearchPage>, Error> {

    let shell = Shell::new(&app, "/search", &viewer);

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

    if query.is_empty() {

        return Ok(Page(SearchPage { shell, q: query, repos: vec![], accounts: vec![], hits: vec![] }));

    }

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

    // What the viewer may see.

    let all = db::repos::list(&app.db).await.map_err(e)?;

    let mut visible = Vec::new();

    for r in all {

        let role = crate::auth::roles::role_for(&app.db, viewer.account(), &r).await.map_err(e)?;

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

            visible.push(r);

        }

    }

    let lower = query.to_lowercase();

    let repos: Vec<db::repos::RepoRow> = visible

        .iter()

        .filter(|r| {

            r.name.to_lowercase().contains(&lower)

                || r.description.to_lowercase().contains(&lower)

                || r.owner.to_lowercase().contains(&lower)

        })

        .cloned()

        .collect();

    let accounts: Vec<String> = accounts::accounts(&app.db)

        .await

        .map_err(e)?

        .into_iter()

        .filter(|a| a.username.to_lowercase().contains(&lower) || a.display_name.to_lowercase().contains(&lower))

        .map(|a| a.username)

        .collect();

    let mut hits = Vec::new();

    for h in ndb::search(&app.db, &query, None, 100).await.map_err(e)? {

        let Some(r) = visible.iter().find(|r| r.id == h.repo_id) else { continue };

        let url = format!("/{}/{}/{}", r.slug(), if h.kind == "proposal" { "proposal" } else { "issue" }, h.number);

        hits.push(HitView {

            kind: h.kind,

            slug: r.slug(),

            number: h.number,

            title: h.title,

            snippet: crate::render::escape(&h.snippet).replace("&lt;mark&gt;", "<mark>").replace("&lt;/mark&gt;", "</mark>"),

            url,

        });

    }

    let _ = Visibility::Public;

    Ok(Page(SearchPage { shell, q: query, repos, accounts, hits }))

}