use crate::{
    AppState, Backend, NameUpdateError,
    language::language,
    page::{MyMessage, Page},
};
use axum::{
    Form, Router,
    extract::{Path, State},
    http::HeaderMap,
    response::{IntoResponse, Response},
    routing::{get, post},
};
use axum_extra::extract::{CookieJar, PrivateCookieJar};
use maud::{Markup, PreEscaped, html};
use serde::Deserialize;
use std::sync::Arc;
use uuid::Uuid;

async fn index(
    State(backend): State<Arc<Backend>>,
    cookies: PrivateCookieJar,
    lang_cookies: CookieJar,
    headers: HeaderMap,
) -> Response {
    retu(backend, cookies, lang_cookies, headers, None).await
}

async fn retu(
    backend: Arc<Backend>,
    cookies: PrivateCookieJar,
    lang_cookies: CookieJar,
    headers: HeaderMap,
    message: Option<MyMessage>,
) -> Response {
    let (cookies, req) = backend.client_full(cookies, &lang_cookies, &headers).await;
    let client = req.client;
    rust_i18n::set_locale(&req.lang.to_string());

    let sightings = backend.sightings_for_client(&client).await;
    let amount_total_cameras = backend.amount_total_cameras().await;
    let highscore = backend.highscore().await;

    let mut page = Page::new(req.lang);
    if let Some(message) = message {
        page.set_message(message);
    }
    let markup = page.content(html! {
        hgroup {
            h1 { (t!("game_title")) }
        }
        p {
            mark { (t!("game_explanation_todo")) }
        }

        div.mb-sm { (t!("ask_to_change_name", name = client.get_display_name())) }

        form action="/game" method="post" {
            fieldset role="group" {
                input
                    name="name"
                    placeholder=(t!("funny_name_change_placeholder"))
                    aria-label="Name"
                    required;
                input type="submit" value=(t!("save_button"));
            }
        }

        p.mb-0 {
            ({
                t!(
                    "cameras_found", found = sightings.len(), total =
                    amount_total_cameras
                )
            })
            progress value=(sightings.len()) max=(amount_total_cameras);
        }

        ol.flex.small {
            @for sighting in &sightings {
                li { (sighting.camera.name) }
            }
        }

        p {
            h2 { (t!("highscore_title")) }
            ul.iterated {
                @for rank in highscore {
                    li.card {
                        span {
                            span.font-headline.rank.text-muted { (rank.rank) "." }
                            @if rank.client == client { (PreEscaped("<mark id='ranking'>")) }
                            (rank.client.get_display_name())
                            @if rank.client == client { (PreEscaped("</mark>")) }
                        }
                        span.font-headline.font-lg {
                            (rank.amount)
                            (PreEscaped("&nbsp;"))
                            (t!("icon_camera"))
                        }
                    }
                }
            }
        }
    });

    (cookies, markup).into_response()
}

async fn game(
    State(backend): State<Arc<Backend>>,
    cookies: PrivateCookieJar,
    lang_cookies: CookieJar,
    headers: HeaderMap,
    Path(uuid): Path<String>,
) -> Response {
    let (cookies, req) = backend.client_full(cookies, &lang_cookies, &headers).await;
    let client = req.client;
    rust_i18n::set_locale(req.lang.to_locale());

    let Ok(uuid) = Uuid::parse_str(&uuid) else {
        return not_found(lang_cookies, headers).await.into_response();
    };

    let Some(camera) = backend.get_camera(&uuid).await else {
        return not_found(lang_cookies, headers).await.into_response();
    };

    let message = if let Ok(number) = backend.client_found_camera(&client, &camera).await {
        MyMessage::FoundCam(camera.name, number)
    } else {
        MyMessage::Error(
            t!("error_already_found_title").into(),
            t!("error_already_found_body").into(),
            t!("error_already_found_footer").into(),
        )
    };

    retu(backend, cookies, lang_cookies, headers, Some(message)).await
}

async fn not_found(cookies: CookieJar, headers: HeaderMap) -> Markup {
    let lang = language(&cookies, &headers);
    Page::new(lang).content(html! {
        h1 { (t!("not_found_title")) }
    })
}

#[derive(Deserialize)]
struct NameForm {
    name: String,
}

async fn set_name(
    State(backend): State<Arc<Backend>>,
    cookies: PrivateCookieJar,
    lang_cookies: CookieJar,
    headers: HeaderMap,
    Form(form): Form<NameForm>,
) -> Response {
    let (cookies, req) = backend.client_full(cookies, &lang_cookies, &headers).await;
    let client = req.client;
    rust_i18n::set_locale(req.lang.to_locale());

    let message = match backend.set_client_name(&client, &form.name).await {
        Ok(()) => MyMessage::NameChanged,
        Err(NameUpdateError::TooShort(expected, actual)) => MyMessage::Error(
            t!("error_name_too_short_title").into(),
            t!("error_name_too_short_body", expected = expected).into(),
            format!("{}: {actual}", t!("received_characters")),
        ),
        Err(NameUpdateError::TooLong(expected, actual)) => MyMessage::Error(
            t!("error_name_too_long_title").into(),
            t!("error_name_too_long_body", expected = expected).into(),
            format!("{}: {actual}", t!("received_characters")),
        ),
        Err(NameUpdateError::ContainsBadWord) => MyMessage::Error(
            t!("error_bad_word_title").into(),
            t!("error_bad_word_body").into(),
            t!("error_bad_word_footer").into(),
        ),
    };

    retu(backend, cookies, lang_cookies, headers, Some(message)).await
}

pub(super) fn routes() -> Router<AppState> {
    Router::new()
        .route("/game", get(index))
        .route("/game", post(set_name))
        .route("/{*uuid}", get(game))
}