//! Pages (hub spec §6): the router, the shell every template extends, the

//! error page, viewer-aware lookups and askama filters. Handlers are thin:

//! they resolve names, call the view layer under the repository lock, and

//! render.

mod admin;

pub mod filters;

mod history;

mod home;

mod orgs;

pub mod proposals;

mod refs;

mod repo;

mod repo_settings;

mod session;

mod settings;

mod statics;

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

use crate::repos::RepoError;

use crate::{db, Shared};

use askama::Template;

use axum::extract::DefaultBodyLimit;

use axum::http::{header, StatusCode};

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

use axum::routing::{any, get, post};

use axum::Router;

use tower_http::compression::CompressionLayer;

use tower_http::trace::TraceLayer;

pub fn router(app: Shared) -> Router {

    let push_limit = app.config.limits.push_body_limit.0 as usize;

    Router::new()

        .route("/", get(home::index))

        .route("/explore", get(home::explore))

        .route("/health", get(home::health))

        .route("/.well-known/oxyhub-key", get(home::hub_key))

        .route("/style.css", get(statics::style))

        .route("/favicon.svg", get(statics::favicon))

        .route("/favicon.ico", get(statics::favicon))

        .route("/static/{*path}", get(statics::asset))

        .route("/login", get(session::login_form).post(session::login))

        .route("/logout", post(session::logout))

        .route("/register", get(session::register_form).post(session::register))

        .route("/settings", get(settings::profile).post(settings::update_profile))

        .route("/settings/password", post(settings::change_password))

        .route("/settings/security", get(settings::security))

        .route("/settings/security/totp/begin", post(settings::totp_begin))

        .route("/settings/security/totp/enable", post(settings::totp_enable))

        .route("/settings/security/totp/disable", post(settings::totp_disable))

        .route("/settings/security/sessions", post(settings::sessions_reset))

        .route("/settings/keys", get(settings::keys))

        .route("/settings/keys/upload", post(settings::keys_upload))

        .route("/settings/keys/verify", post(settings::keys_verify))

        .route("/settings/keys/unlink", post(settings::keys_unlink))

        .route("/settings/tokens", get(settings::tokens).post(settings::tokens_create))

        .route("/settings/tokens/{id}/delete", post(settings::tokens_delete))

        .route("/new", get(repo_settings::new_form).post(repo_settings::create))

        .route("/orgs/new", get(orgs::new_form).post(orgs::create))

        .route("/orgs/{name}/settings", get(orgs::settings).post(orgs::update))

        .route("/orgs/{name}/settings/members", post(orgs::member))

        .route("/orgs/{name}/settings/teams", post(orgs::team))

        .route("/admin", get(admin::index))

        .route("/admin/registration", post(admin::set_mode))

        .route("/admin/invite", post(admin::invite))

        .route("/admin/account", post(admin::account))

        .nest("/api/v1", crate::api::router())

        .route("/{owner}", get(home::owner))

        .route("/{owner}/{name}", get(repo::overview))

        .route("/{owner}/{name}/tree/{r}", get(repo::tree_root))

        .route("/{owner}/{name}/tree/{r}/{*path}", get(repo::tree))

        .route("/{owner}/{name}/file/{r}/{*path}", get(repo::file))

        .route("/{owner}/{name}/last/{r}", get(repo::last_changes))

        .route("/{owner}/{name}/changes/{r}", get(history::history))

        .route("/{owner}/{name}/change/{hash}", get(history::change))

        .route("/{owner}/{name}/compare/{spec}", get(history::compare))

        .route("/{owner}/{name}/bookmarks", get(refs::bookmarks))

        .route("/{owner}/{name}/tags", get(refs::tags))

        .route("/{owner}/{name}/conflicts", get(refs::conflicts))

        .route("/{owner}/{name}/trust", get(refs::trust))

        .route("/{owner}/{name}/pushes", get(refs::pushes))

        .route("/{owner}/{name}/settings", get(repo_settings::settings).post(repo_settings::update))

        .route("/{owner}/{name}/settings/collaborators", post(repo_settings::collaborator))

        .route("/{owner}/{name}/settings/delete", post(repo_settings::delete))

        .route("/{owner}/{name}/settings/requirements", post(repo_settings::requirements))

        .route("/{owner}/{name}/proposals", get(proposals::list))

        .route("/{owner}/{name}/proposals/new", get(proposals::new_form).post(proposals::create))

        .route("/{owner}/{name}/proposal/{number}", get(proposals::show))

        .route("/{owner}/{name}/proposal/{number}/comment", post(proposals::comment))

        .route("/{owner}/{name}/proposal/{number}/comment/{id}/resolve", post(proposals::resolve_comment))

        .route("/{owner}/{name}/proposal/{number}/review", post(proposals::review))

        .route("/{owner}/{name}/proposal/{number}/edit", post(proposals::edit))

        .route("/{owner}/{name}/proposal/{number}/state", post(proposals::state))

        .route("/{owner}/{name}/proposal/{number}/land", post(proposals::land))

        .route("/{owner}/{name}/oxy/v1/{endpoint}", any(crate::protocol::dispatch).layer(DefaultBodyLimit::max(push_limit)))

        .fallback(not_found)

        .layer(axum::middleware::from_fn_with_state(app.clone(), same_origin))

        .layer(CompressionLayer::new())

        .layer(TraceLayer::new_for_http())

        .with_state(app)

}

/// Cross-site form posts are refused (hub spec §15.2): a browser that

/// sends `Origin` or `Sec-Fetch-Site` must name this site. Protocol and

/// API clients send neither.

async fn same_origin(

    axum::extract::State(app): axum::extract::State<Shared>,

    req: axum::extract::Request,

    next: axum::middleware::Next,

) -> Response {

    if req.method() != axum::http::Method::GET && req.method() != axum::http::Method::HEAD {

        let headers = req.headers();

        if headers.get("sec-fetch-site").and_then(|v| v.to_str().ok()) == Some("cross-site") {

            return (StatusCode::FORBIDDEN, "cross-site request refused").into_response();

        }

        if let Some(origin) = headers.get(header::ORIGIN).and_then(|v| v.to_str().ok()) {

            let host_of = |u: &str| u.split("://").nth(1).unwrap_or(u).split('/').next().unwrap_or("").to_ascii_lowercase();

            let request_host = headers.get(header::HOST).and_then(|v| v.to_str().ok()).map(|h| h.to_ascii_lowercase());

            let ok = host_of(origin) == host_of(app.config.base_url()) || request_host.as_deref() == Some(host_of(origin).as_str());

            if !ok && origin != "null" {

                return (StatusCode::FORBIDDEN, "cross-site request refused").into_response();

            }

        }

    }

    next.run(req).await

}

/// What every page's chrome needs.

#[derive(Clone, Debug)]

pub struct Shell {

    pub site: String,

    pub base_url: String,

    pub path: String,

    pub version: &'static str,

    /// The signed-in username, if any.

    pub user: Option<String>,

    pub is_admin: bool,

    pub csrf: String,

}

impl Shell {

    pub fn new(app: &Shared, path: &str, viewer: &Viewer) -> Shell {

        Shell {

            site: app.config.site.name.clone(),

            base_url: app.config.base_url().to_string(),

            path: path.to_string(),

            version: env!("CARGO_PKG_VERSION"),

            user: viewer.account().map(|a| a.username.clone()),

            is_admin: viewer.is_admin(),

            csrf: viewer.csrf().to_string(),

        }

    }

    pub fn anonymous(app: &Shared, path: &str) -> Shell {

        Shell::new(app, path, &Viewer(None))

    }

}

/// The repository chrome: tabs and counts.

#[derive(Clone, Debug)]

pub struct RepoShell {

    pub owner: String,

    pub name: String,

    pub url: String,

    pub description: String,

    pub default_bookmark: String,

    pub visibility: String,

    pub tab: &'static str,

    pub clone_url: String,

    /// The viewer's role, for showing settings and write actions.

    pub role: Option<Role>,

}

impl RepoShell {

    pub fn new(app: &Shared, row: &db::repos::RepoRow, tab: &'static str) -> RepoShell {

        RepoShell {

            owner: row.owner.clone(),

            name: row.name.clone(),

            url: format!("/{}/{}", row.owner, row.name),

            description: row.description.clone(),

            default_bookmark: row.default_bookmark.clone(),

            visibility: row.visibility.clone(),

            tab,

            clone_url: format!("{}/{}/{}", app.config.base_url(), row.owner, row.name),

            role: None,

        }

    }

    pub fn with_role(mut self, role: Role) -> RepoShell {

        self.role = Some(role);

        self

    }

    pub fn can(&self, access: Access) -> bool {

        auth::roles::allows(self.role, access)

    }

    pub fn can_maintain(&self) -> bool {

        self.can(Access::Maintain)

    }

}

/// Render a template as an HTML response.

pub struct Page<T: Template>(pub T);

impl<T: Template> IntoResponse for Page<T> {

    fn into_response(self) -> Response {

        match self.0.render() {

            Ok(s) => Html(s).into_response(),

            Err(e) => {

                tracing::error!("template: {e}");

                (StatusCode::INTERNAL_SERVER_ERROR, "template error").into_response()

            }

        }

    }

}

#[derive(Template)]

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

struct ErrorPage {

    shell: Shell,

    status: u16,

    title: String,

    detail: String,

}

/// A page-level failure, rendered inside the shell, or a redirect.

#[derive(Debug)]

pub struct Error {

    pub status: StatusCode,

    pub detail: String,

    shell: Option<Box<Shell>>,

    redirect: Option<String>,

}

impl Error {

    pub fn redirect(to: String) -> Error {

        Error { status: StatusCode::SEE_OTHER, detail: String::new(), shell: None, redirect: Some(to) }

    }

    pub fn not_found(shell: Shell) -> Error {

        Error {

            status: StatusCode::NOT_FOUND,

            detail: "There is nothing at this address.".into(),

            shell: Some(Box::new(shell)),

            redirect: None,

        }

    }

    pub fn bad(shell: Shell, detail: impl Into<String>) -> Error {

        Error { status: StatusCode::BAD_REQUEST, detail: detail.into(), shell: Some(Box::new(shell)), redirect: None }

    }

    pub fn from_repo(shell: Shell, e: RepoError) -> Error {

        match e {

            RepoError::NotFound => Error::not_found(shell),

            RepoError::Oxy(oxy_core::repo::RepoError::Msg(m)) => {

                Error { status: StatusCode::NOT_FOUND, detail: m, shell: Some(Box::new(shell)), redirect: None }

            }

            other => {

                Error { status: StatusCode::INTERNAL_SERVER_ERROR, detail: other.to_string(), shell: Some(Box::new(shell)), redirect: None }

            }

        }

    }

    pub fn from_db(shell: Shell, e: sqlx::Error) -> Error {

        Error { status: StatusCode::INTERNAL_SERVER_ERROR, detail: e.to_string(), shell: Some(Box::new(shell)), redirect: None }

    }

}

impl IntoResponse for Error {

    fn into_response(self) -> Response {

        if let Some(to) = self.redirect {

            return Redirect::to(&to).into_response();

        }

        let title = match self.status {

            StatusCode::NOT_FOUND => "Not found",

            StatusCode::BAD_REQUEST => "Bad request",

            _ => "Something went wrong",

        };

        if self.status.is_server_error() {

            tracing::error!("{}", self.detail);

        }

        let shell = self.shell.map(|b| *b).unwrap_or(Shell {

            site: "Oxygenhub".into(),

            base_url: String::new(),

            path: String::new(),

            version: "",

            user: None,

            is_admin: false,

            csrf: String::new(),

        });

        let page = ErrorPage { shell, status: self.status.as_u16(), title: title.into(), detail: self.detail };

        match page.render() {

            Ok(s) => (self.status, Html(s)).into_response(),

            Err(_) => (self.status, title).into_response(),

        }

    }

}

async fn not_found(axum::extract::State(app): axum::extract::State<Shared>, viewer: Viewer, uri: axum::http::Uri) -> Response {

    Error::not_found(Shell::new(&app, uri.path(), &viewer)).into_response()

}

/// A raw file response with a safe content type (hub spec §15.2).

pub fn raw(bytes: Vec<u8>, name: &str, inline_image: bool) -> Response {

    let mime = mime_of(name);

    let disposition = if inline_image && mime.starts_with("image/") { "inline" } else { "attachment" };

    (

        [

            (header::CONTENT_TYPE, mime.to_string()),

            (header::CONTENT_DISPOSITION, format!("{disposition}; filename=\"{}\"", name.replace('"', ""))),

            (header::X_CONTENT_TYPE_OPTIONS, "nosniff".to_string()),

        ],

        bytes,

    )

        .into_response()

}

pub fn mime_of(name: &str) -> &'static str {

    match name.rsplit('.').next().map(|e| e.to_ascii_lowercase()).as_deref() {

        Some("png") => "image/png",

        Some("jpg" | "jpeg") => "image/jpeg",

        Some("gif") => "image/gif",

        Some("webp") => "image/webp",

        Some("svg") => "image/svg+xml",

        Some("pdf") => "application/pdf",

        Some(

            "txt" | "md" | "rs" | "toml" | "json" | "yml" | "yaml" | "c" | "h" | "cpp" | "hpp" | "py" | "js" | "ts" | "html" | "css" | "sh",

        ) => "text/plain; charset=utf-8",

        _ => "application/octet-stream",

    }

}

/// Resolve `{owner}/{name}` for the viewer with at least `access`, or 404:

/// a repository the viewer may not see does not exist for them (hub spec

/// §4.4). Returns the viewer's role too.

pub async fn lookup_role(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

    owner: &str,

    name: &str,

    access: Access,

) -> Result<(crate::repos::RepoName, db::repos::RepoRow, Role), Error> {

    let repo = crate::repos::RepoName::new(owner, name).ok_or_else(|| Error::not_found(shell.clone()))?;

    let row = db::repos::get(&app.db, owner, name)

        .await

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

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

    let role = auth::roles::role_for(&app.db, viewer.account(), &row).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if !auth::roles::allows(role, access) {

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

    }

    Ok((repo, row, role.unwrap_or(Role::Read)))

}

/// `lookup_role` for reading.

pub async fn lookup(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

    owner: &str,

    name: &str,

) -> Result<(crate::repos::RepoName, db::repos::RepoRow, Role), Error> {

    lookup_role(app, shell, viewer, owner, name, Access::Read).await

}

/// Fill `account` on change authors whose key is linked to an account.

pub async fn attribute(app: &Shared, changes: &mut [&mut crate::repos::view::ChangeView]) {

    if changes.is_empty() {

        return;

    }

    let Ok(links) = db::accounts::identity_accounts(&app.db).await else { return };

    let map: std::collections::HashMap<String, String> = links.into_iter().collect();

    for c in changes.iter_mut() {

        if let Some(u) = map.get(&c.author.key) {

            c.author.account = Some(u.clone());

        }

    }

}