//! The front page, explore, owner pages and small endpoints.

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

use crate::auth::Viewer;

use crate::{db, Shared};

use askama::Template;

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

use axum::http::header;

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

use hub_api::Visibility;

use serde::Deserialize;

#[derive(Template)]

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

pub struct HomePage {

    shell: Shell,

    description: String,

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

    owner: Option<String>,

    /// Explore's controls: the filter text, the sort, the topic.

    q: String,

    sort: String,

    topic: String,

    stars: std::collections::HashMap<i64, i64>,

}

impl HomePage {

    fn star_count(&self, id: &i64) -> i64 {

        self.stars.get(id).copied().unwrap_or(0)

    }

}

/// `/explore?q=&sort=activity|stars|name&topic=`.

#[derive(Deserialize, Default)]

pub struct ExploreQuery {

    #[serde(default)]

    q: String,

    #[serde(default)]

    sort: String,

    #[serde(default)]

    topic: String,

}

/// The signed-in dashboard (hub spec §6): the review queue, the

/// viewer's own proposals and assigned issues, their repositories and

/// recent activity across everything they can see.

#[derive(Template)]

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

pub struct Dashboard {

    shell: Shell,

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

    reviews: Vec<db::activity::ProposalLine>,

    authored: Vec<db::activity::ProposalLine>,

    assigned: Vec<db::activity::IssueLine>,

    feed: Vec<db::activity::Activity>,

    /// Your sky's data (docs/backgrounds.md §5), JSON safe inside a script.

    backdrop: String,

}

/// How many activity lines the dashboard shows.

const FEED_LIMIT: i64 = 40;

/// The most events Your sky draws, and how far back (docs/backgrounds.md §5).

const SKY_EVENTS: i64 = 400;

const SKY_DAYS: i64 = 30;

/// Your sky's data (docs/backgrounds.md §5): the viewer's repositories and

/// their events of the last 30 days, newest first, as

/// `{now, repos: [slug], events: [[repo, kind, at_ms]]}` with kinds 0 push,

/// 1 proposal, 2 issue, 3 release. Only the database is read, never a

/// repository's store; `<` is escaped so the JSON is safe in a script.

fn sky_json(mine: &[db::repos::RepoRow], events: &[db::activity::Activity], now: i64) -> String {

    let slugs: Vec<String> = mine.iter().map(|r| format!("{}/{}", r.owner, r.name)).collect();

    let since = now - SKY_DAYS * 86_400_000;

    let evs: Vec<serde_json::Value> = events

        .iter()

        .filter(|e| e.at_ms >= since)

        .filter_map(|e| {

            let repo = slugs.iter().position(|s| *s == format!("{}/{}", e.owner, e.name))?;

            let kind = match e.kind.as_str() {

                "proposal" => 1,

                "issue" => 2,

                "release" => 3,

                _ => 0,

            };

            Some(serde_json::json!([repo, kind, e.at_ms]))

        })

        .collect();

    serde_json::json!({ "now": now, "repos": slugs, "events": evs }).to_string().replace('<', "\\u003c")

}

/// `/`: the dashboard when signed in, every visible repository otherwise.

pub async fn index(State(app): State<Shared>, viewer: Viewer) -> Result<Response, Error> {

    let Some(account) = viewer.account().cloned() else {

        return Ok(explore(State(app), viewer, Query(ExploreQuery::default())).await?.into_response());

    };

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

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

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

    let member: Vec<i64> = db::accounts::visible_repo_ids(&app.db, account.id).await.map_err(db_err)?;

    let seen = visible(&app, &shell, &viewer, all).await?;

    let seen_ids: Vec<i64> = seen.iter().map(|r| r.id).collect();

    let mut mine: Vec<db::repos::RepoRow> = seen.into_iter().filter(|r| member.contains(&r.id)).collect();

    mine.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

    let reviews = db::activity::awaiting_review(&app.db, account.id, &member).await.map_err(db_err)?;

    let authored = db::activity::authored(&app.db, account.id, &seen_ids).await.map_err(db_err)?;

    let assigned = db::activity::assigned(&app.db, account.id, &seen_ids).await.map_err(db_err)?;

    let feed = db::activity::feed(&app.db, &seen_ids, FEED_LIMIT).await.map_err(db_err)?;

    let mine_ids: Vec<i64> = mine.iter().map(|r| r.id).collect();

    let sky = db::activity::feed(&app.db, &mine_ids, SKY_EVENTS).await.map_err(db_err)?;

    let backdrop = sky_json(&mine, &sky, db::now_ms());

    Ok(Page(Dashboard { shell, mine, reviews, authored, assigned, feed, backdrop }).into_response())

}

/// `/explore`: every repository the viewer may see, filtered by text and

/// topic, sorted by recent activity (the default), stars or name.

pub async fn explore(State(app): State<Shared>, viewer: Viewer, Query(q): Query<ExploreQuery>) -> Result<Page<HomePage>, Error> {

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

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

    let mut repos = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

    let stars = db::repos::star_counts(&app.db).await.map_err(db_err)?;

    let needle = q.q.trim().to_lowercase();

    if !needle.is_empty() {

        repos.retain(|r| {

            r.slug().to_lowercase().contains(&needle)

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

                || r.topic_list().iter().any(|t| t.contains(&needle))

        });

    }

    let topic = q.topic.trim().to_lowercase();

    if !topic.is_empty() {

        repos.retain(|r| r.topic_list().contains(&topic.as_str()));

    }

    let sort = match q.sort.as_str() {

        "stars" | "name" => q.sort.clone(),

        _ => "activity".to_string(),

    };

    match sort.as_str() {

        "stars" => repos.sort_by_key(|r| (std::cmp::Reverse(stars.get(&r.id).copied().unwrap_or(0)), std::cmp::Reverse(r.updated_ms))),

        "name" => repos.sort_by_key(|r| (r.name.to_lowercase(), r.owner.to_lowercase())),

        _ => repos.sort_by_key(|r| std::cmp::Reverse(r.updated_ms)),

    }

    Ok(Page(HomePage { description: app.config.site.description.clone(), shell, repos, owner: None, q: q.q, sort, topic, stars }))

}

/// A person's page (hub spec §6): avatar, names, bio, linked signing

/// keys, organisations, repositories and what they did lately.

#[derive(Template)]

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

pub struct ProfilePage {

    shell: Shell,

    account: db::accounts::Account,

    keys: Vec<db::accounts::LinkedIdentity>,

    orgs: Vec<(db::accounts::Organisation, String)>,

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

    feed: Vec<db::activity::Activity>,

    is_me: bool,

}

impl ProfilePage {

    /// The website as a link only when it is http(s).

    fn website_href(&self) -> Option<&str> {

        let w = self.account.website.trim();

        (w.starts_with("https://") || w.starts_with("http://")).then_some(w)

    }

}

/// An organisation's page: description, members with their roles, teams,

/// repositories and recent activity in them.

#[derive(Template)]

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

pub struct OrgPage {

    shell: Shell,

    org: db::accounts::Organisation,

    members: Vec<(db::accounts::Account, String)>,

    teams: Vec<(db::accounts::Team, usize)>,

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

    feed: Vec<db::activity::Activity>,

    can_admin: bool,

}

/// How many activity lines an owner page shows.

const OWNER_FEED: i64 = 20;

/// `/{owner}`: a person's profile, an organisation's page, or (for an

/// owner that is neither, such as repositories an administrator created

/// for a name nobody holds) the list of its repositories.

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

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

    if !crate::repos::names::valid_owner(&owner) {

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

    }

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

    let mut repos = visible(&app, &shell, &viewer, db::repos::list_by_owner(&app.db, &owner).await.map_err(db_err)?).await?;

    repos.sort_by_key(|r| std::cmp::Reverse(r.updated_ms));

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

        // What they did anywhere the viewer can see, not only in their own repositories.

        let all = visible(&app, &shell, &viewer, db::repos::list(&app.db).await.map_err(db_err)?).await?;

        let ids: Vec<i64> = all.iter().map(|r| r.id).collect();

        let feed = db::activity::feed_by(&app.db, &ids, Some(&account.username), OWNER_FEED).await.map_err(db_err)?;

        let keys = db::accounts::identities_of(&app.db, account.id).await.map_err(db_err)?;

        let orgs = db::accounts::orgs_of(&app.db, account.id).await.map_err(db_err)?;

        let is_me = viewer.account().is_some_and(|a| a.id == account.id);

        return Ok(Page(ProfilePage { shell, account, keys, orgs, repos, feed, is_me }).into_response());

    }

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

        let members = db::accounts::org_members(&app.db, org.id).await.map_err(db_err)?;

        let mut teams = Vec::new();

        for t in db::accounts::teams(&app.db, org.id).await.map_err(db_err)? {

            let n = db::accounts::team_members(&app.db, t.id).await.map_err(db_err)?.len();

            teams.push((t, n));

        }

        let ids: Vec<i64> = repos.iter().map(|r| r.id).collect();

        let feed = db::activity::feed(&app.db, &ids, OWNER_FEED).await.map_err(db_err)?;

        let can_admin =

            viewer.is_admin() || viewer.account().is_some_and(|a| members.iter().any(|(m, role)| m.id == a.id && role == "owner"));

        return Ok(Page(OrgPage { shell, org, members, teams, repos, feed, can_admin }).into_response());

    }

    if repos.is_empty() {

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

    }

    let stars = db::repos::star_counts(&app.db).await.unwrap_or_default();

    Ok(Page(HomePage {

        description: String::new(),

        shell,

        repos,

        owner: Some(owner),

        q: String::new(),

        sort: "activity".into(),

        topic: String::new(),

        stars,

    })

    .into_response())

}

/// The repositories among `rows` the viewer may see: public ones, internal

/// ones when signed in, and those the viewer owns or collaborates on.

pub(crate) async fn visible(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

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

) -> Result<Vec<db::repos::RepoRow>, Error> {

    let mine: Vec<i64> = match viewer.account() {

        Some(a) if a.is_admin => rows.iter().map(|r| r.id).collect(),

        Some(a) => db::accounts::visible_repo_ids(&app.db, a.id).await.map_err(|e| Error::from_db(shell.clone(), e))?,

        None => vec![],

    };

    let signed_in = viewer.signed_in();

    Ok(rows

        .into_iter()

        .filter(|r| match r.visibility() {

            Visibility::Public => true,

            Visibility::Internal => signed_in,

            Visibility::Private => mine.contains(&r.id),

        })

        .collect())

}

pub async fn health(State(app): State<Shared>) -> Response {

    let body = serde_json::json!({

        "ok": true,

        "version": env!("CARGO_PKG_VERSION"),

        "build": env!("OXY_BUILD_ID"),

        "uptime_s": app.started.elapsed().as_secs(),

    });

    axum::Json(body).into_response()

}

/// The hub delegate identity object (hub spec §15.5), as `oxy identity

/// export` writes one, so policy holders can admit it.

pub async fn hub_key(State(app): State<Shared>) -> Response {

    (

        [(header::CONTENT_TYPE, "application/oxy-identity"), (header::CONTENT_DISPOSITION, "attachment; filename=\"hub.identity\"")],

        app.hub_key.bytes.clone(),

    )

        .into_response()

}

/// The hub's TLS certificate (hub spec §15.5), for clients of a

/// developer edition with a self-signed certificate: save it and point

/// `oxy` at it with `OXY_CA` or `oxy config remote.<name>.ca`.

pub async fn hub_ca(State(app): State<Shared>) -> Response {

    if !app.config.tls.self_signed {

        return (axum::http::StatusCode::NOT_FOUND, "this hub does not use a self-signed certificate").into_response();

    }

    match tokio::fs::read(app.config.tls_cert()).await {

        Ok(pem) => (

            [(header::CONTENT_TYPE, "application/x-pem-file"), (header::CONTENT_DISPOSITION, "attachment; filename=\"oxyhub-ca.pem\"")],

            pem,

        )

            .into_response(),

        Err(_) => (axum::http::StatusCode::NOT_FOUND, "no certificate").into_response(),

    }

}

/// What this hub is built from (hub spec §15): its version and build, and

/// the versions of the Oxygen and OxygenFlow libraries it links.

pub fn versions() -> serde_json::Value {

    serde_json::json!({

        "oxygenhub": { "version": env!("CARGO_PKG_VERSION"), "build": env!("OXY_BUILD_ID") },

        "oxy_core": oxy_core::VERSION,

        "flow_core": flow_core::VERSION,

    })

}

#[derive(askama::Template)]

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

pub struct AboutPage {

    shell: Shell,

    oxy_core: &'static str,

    flow_core: &'static str,

    /// Runners and the versions they report, for administrators.

    runners: Vec<crate::db::runners::Runner>,

}

/// `GET /about`: the hub's version and what it is built on; runners too, for

/// administrators.

pub async fn about(State(app): State<Shared>, viewer: Viewer) -> Result<Page<AboutPage>, Error> {

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

    let runners = if viewer.is_admin() { crate::db::runners::list(&app.db).await.unwrap_or_default() } else { vec![] };

    Ok(Page(AboutPage { shell, oxy_core: oxy_core::VERSION, flow_core: flow_core::VERSION, runners }))

}