use axum::{
    Json,
    extract::{Query, State},
};
use serde::{Deserialize, Serialize};
use sqlx::{PgPool, query, query_as, types::Uuid};
use tower_sessions::Session;

use crate::error::AppError;

#[derive(Deserialize, Serialize)]
pub struct Weapon {
    id: Uuid,
    name: String,
    display: String,
    def_index: i32,
    category: String,
    team: i32,
}

#[derive(Deserialize, Serialize)]
pub struct SkinInfo {
    id: Uuid,
    name: String,
    display: String,
    paint_index: i32,
    color: String,
    float: f64,
    pattern: i32,
}

#[axum::debug_handler]
pub async fn weapons(State(pool): State<PgPool>) -> Result<Json<Vec<Weapon>>, AppError> {
    let weapons = query_as!(Weapon, "SELECT * FROM weapons")
        .fetch_all(&pool)
        .await?;
    Ok(Json(weapons))
}

#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
enum Teams {
    CT,
    T,
    BOTH,
}

impl Teams {
    fn as_i32(self) -> i32 {
        match self {
            Teams::CT => 0,
            Teams::T => 1,
            Teams::BOTH => 2,
        }
    }
}

#[derive(Deserialize, Serialize, Copy, Clone, Debug)]
enum Categories {
    Knives,
    Gloves,
    Rifles,
    SMGs,
    Pistols,
    Heavy,
    Equipment,
}

impl Categories {
    fn as_str(self) -> &'static str {
        match self {
            Categories::Knives => "Knives",
            Categories::Gloves => "Gloves",
            Categories::Rifles => "Rifles",
            Categories::SMGs => "SMGs",
            Categories::Pistols => "Pistols",
            Categories::Heavy => "Heavy",
            Categories::Equipment => "Equipment",
        }
    }
}

#[derive(Deserialize, Serialize)]
pub struct SkinInfoQuery {
    category: Option<Categories>,
    team: Option<Teams>,
}

pub async fn skin_info(
    State(pool): State<PgPool>,
    session: Session,
    Query(info_query): Query<SkinInfoQuery>,
) -> Result<Json<Vec<SkinInfo>>, AppError> {
    if let Some(uuid) = session.get::<Uuid>("uuid").await? {
        // Fetch all default skins
        let mut default_skins = query!("SELECT w.id, w.name, w.display, w.team, w.category, w.display as wd, s.display as sd, r.color FROM skins s JOIN weapons w ON w.id = s.weapon JOIN rarity r ON r.id = s.rarity WHERE s.default = true").fetch_all(&pool).await?;
        // Filter those skins by team if present in query
        if let Some(team) = info_query.team {
            default_skins = default_skins
                .into_iter()
                .filter(|x| team.as_i32() == x.team || Teams::BOTH.as_i32() == x.team)
                .collect();
        }
        // Same with category
        if let Some(category) = info_query.category {
            default_skins = default_skins
                .into_iter()
                .filter(|x| category.as_str() == x.category)
                .collect();
        }
        // For each remaining default weapon, see if the user has set a skin
        // Secific cases for Knives and Gloves
        let mut skin_infos = vec![];
        for default in default_skins {
            struct Info {
                id: Uuid,
                float: f64,
                pattern: i32,
                team: i32,
                name: String,
                wd: String,
                sd: String,
                paint_index: i32,
                color: String,
            }
            let user_skin = match default.category.as_str() {
                "Gloves" | "Knives" => {
                    query_as!(Info, "SELECT us.id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, r.color FROM user_skins us JOIN skins s ON us.skin_id = s.id JOIN weapons w ON s.weapon = w.id JOIN rarity r ON r.id = s.rarity WHERE us.user_id = $1 AND w.category = $2", uuid, default.category).fetch_all(&pool).await?
                },
                _ =>  {
                    query_as!(Info, "SELECT us.id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, r.color FROM user_skins us JOIN skins s ON us.skin_id = s.id JOIN weapons w ON s.weapon = w.id JOIN rarity r ON r.id = s.rarity WHERE us.user_id = $1 AND w.id = $2", uuid, default.id).fetch_all(&pool).await?
                }
            };
            let user_skin = if let Some(team) = info_query.team {
                user_skin
                    .into_iter()
                    .filter(|x| x.team == team.as_i32() || x.team == Teams::BOTH.as_i32())
                    .min_by(|x, y| x.team.cmp(&y.team))
                    .unwrap_or(Info {
                        id: Uuid::nil(),
                        float: 0.0,
                        pattern: 0,
                        team: 2,
                        name: default.name,
                        wd: default.wd,
                        sd: default.sd,
                        paint_index: 0,
                        color: default.color,
                    })
            } else {
                user_skin
                    .into_iter()
                    .max_by(|x, y| x.team.cmp(&y.team))
                    .unwrap_or(Info {
                        id: Uuid::nil(),
                        float: 0.0,
                        pattern: 0,
                        team: 2,
                        name: default.name,
                        wd: default.wd,
                        sd: default.sd,
                        paint_index: 0,
                        color: default.color,
                    })
            };
            let display = if user_skin.sd.is_empty() {
                user_skin.wd
            } else {
                format!("{} | {}", user_skin.wd, user_skin.sd)
            };
            let info = SkinInfo {
                display,
                id: user_skin.id,
                name: user_skin.name,
                paint_index: user_skin.paint_index,
                color: user_skin.color,
                float: user_skin.float,
                pattern: user_skin.pattern,
            };
            skin_infos.push(info);
        }
        Ok(Json(skin_infos))
    } else {
        Err(AppError::Unauthorised)
    }
}