//! 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,
    rows: Vec<ndb::Notification>,
    unread: i64,
    email_on: bool,
    notice: Option<String>,
}

async fn inbox_page(app: &Shared, shell: Shell, me: &accounts::Account, notice: Option<String>) -> Result<Page<InboxPage>, Error> {
    let rows = ndb::inbox(&app.db, me.id, 200).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let unread = ndb::unread(&app.db, me.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;
    let fresh = accounts::account_by_id(&app.db, me.id).await.ok().flatten();
    Ok(Page(InboxPage { shell, rows, unread, email_on: fresh.map(|a| a.email_notifications).unwrap_or(false), notice }))
}

pub async fn inbox(State(app): State<Shared>, viewer: Viewer) -> Result<Page<InboxPage>, Error> {
    let shell = Shell::new(&app, "/notifications", &viewer);
    let me = require(&viewer, &shell)?;
    inbox_page(&app, shell, &me.account, 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, None).await
}

#[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,
        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 }))
}