use crate::{language::language, page::new, Backend};
use axum::{
    extract::{Path, State},
    http::HeaderMap,
    response::{IntoResponse, Redirect, Response},
    routing::get,
    Router,
};
use axum_extra::extract::CookieJar;
use maud::{html, Markup, PreEscaped};
use std::sync::Arc;
use uuid::Uuid;

async fn index(
    State(backend): State<Arc<Backend>>,
    cookies: CookieJar,
    headers: HeaderMap,
) -> Response {
    let (cookies, req) = backend.client_full(cookies, &headers).await;
    let client = req.client;

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

    let markup = new(
        html! {
            hgroup {
                h1 { "Who finds the most cameras?" }
            }
            p {
                mark { "TODO: Explanation of AEF / digital shadows / search game" }
            }
            p {
                mark { "TODO: Show optional SUCC message" }
            }

            div {
                (client.get_display_name())
                ", do you want to be named something different? No worries, change here 👇"
            }

            form {
                fieldset role="group" {
                    input
                        name="name"
                        placeholder="✨ Your new name starts here ✨"
                        aria-label="Name";
                    input type="submit" value="Save";
                }
            }

            p {
                "You have found "
                (sightings.len())
                "/"
                (amount_total_cameras)
                " cameras:"
                progress value=(sightings.len()) max=(amount_total_cameras);
            }
            p {
                ul.iterated {
                    @for (idx, sighting) in sightings.iter().enumerate() {
                        li.card {
                            span {
                                span.font-headline.rank.text-muted { (idx+1) }
                                (sighting.camera.name)
                            }
                        }
                    }
                }

            }
            p {
                h2 { "Highscore" }
                ul.iterated {
                    @for rank in highscore {
                        li.card {
                            span {
                                span.font-headline.rank.text-muted { (rank.rank) "." }
                                @if rank.client == client { (PreEscaped("<mark>")) }
                                (rank.client.get_display_name())
                                @if rank.client == client { (PreEscaped("</mark>")) }
                            }
                            span.font-headline.font-lg { (rank.amount) (PreEscaped("&nbsp;")) "📸" }
                        }
                    }
                }
            }
        },
        req.lang,
    );

    (cookies, markup).into_response()
}

async fn game(
    State(backend): State<Arc<Backend>>,
    cookies: CookieJar,
    headers: HeaderMap,
    Path(uuid): Path<String>,
) -> Result<Redirect, Response> {
    let (cookies, client) = backend.client(cookies).await;

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

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

    let succ = backend.client_found_camera(&client, &camera).await;
    // TODO: show succ/err based on succ

    Ok(Redirect::to("/game"))
}

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

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