use axum::{
    Json, debug_handler,
    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,
    weapon_id: Uuid,
    name: String,
    display: String,
    paint_index: i32,
    color: String,
    float: f64,
    min_float: f64,
    max_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,
    Weapons, // Special category to get all weapons except gloves and knives
}

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",
            Categories::Weapons => "",
        }
    }
}

#[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 = match category {
                Categories::Weapons => default_skins
                    .into_iter()
                    .filter(|x| {
                        ![Categories::Gloves.as_str(), Categories::Knives.as_str()]
                            .contains(&x.category.as_str())
                    })
                    .collect(),
                _ => 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,
                weapon_id: Uuid,
                float: f64,
                min_float: f64,
                max_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, w.id as weapon_id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, s.min_float, s.max_float, 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, w.id as weapon_id, us.float, us.pattern, us.team, w.name, w.display as wd, s.display as sd, s.paint_index, s.min_float, s.max_float, 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(),
                        weapon_id: default.id,
                        float: 0.0,
                        min_float: 0.0,
                        max_float: 1.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(),
                        weapon_id: default.id,
                        float: 0.0,
                        min_float: 0.0,
                        max_float: 1.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,
                weapon_id: user_skin.weapon_id,
                name: user_skin.name,
                paint_index: user_skin.paint_index,
                color: user_skin.color,
                float: user_skin.float,
                min_float: user_skin.min_float,
                max_float: user_skin.max_float,
                pattern: user_skin.pattern,
            };
            skin_infos.push(info);
        }
        Ok(Json(skin_infos))
    } else {
        Err(AppError::Unauthorised)
    }
}

#[derive(Deserialize, Serialize)]
pub struct AgentInfoQuery {
    team: Teams,
}

#[debug_handler]
pub async fn agent_info(
    State(pool): State<PgPool>,
    session: Session,
    Query(info_query): Query<AgentInfoQuery>,
) -> Result<Json<SkinInfo>, AppError> {
    if let Some(uuid) = session.get::<Uuid>("uuid").await? {
        let agent = query!("SELECT us.id, a.id as weapon_id, a.name, a.display, r.color FROM user_skins us JOIN agents a ON a.id = us.agent_id JOIN rarity r ON r.id = a.rarity WHERE us.user_id=$1 AND us.team=$2", uuid, info_query.team.as_i32()).fetch_optional(&pool).await?;
        match agent {
            Some(agent) => Ok(Json(SkinInfo {
                id: agent.id,
                weapon_id: agent.weapon_id,
                name: agent.name,
                display: agent.display,
                paint_index: 0,
                color: agent.color,
                float: 0.0,
                min_float: 0.0,
                max_float: 0.0,
                pattern: 0,
            })),
            None => {
                let default = query!("SELECT a.name, a.id as weapon_id, a.display, r.color FROM agents a JOIN rarity r ON r.id = a.rarity WHERE a.team = $1 AND a.default = true", info_query.team.as_i32()).fetch_one(&pool).await?;
                Ok(Json(SkinInfo {
                    id: Uuid::nil(),
                    weapon_id: default.weapon_id,
                    name: default.name,
                    display: default.display,
                    paint_index: 0,
                    color: default.color,
                    float: 0.0,
                    min_float: 0.0,
                    max_float: 0.0,
                    pattern: 0,
                }))
            }
        }
    } else {
        Err(AppError::Unauthorised)
    }
}

#[derive(Serialize, Default, Debug)]
pub struct PaintIndexInfo {
    name: String,
    paint_index: i32,
    display: String,
    color: String,
    min_float: f64,
    max_float: f64,
}

#[derive(Deserialize)]
pub struct PaintQuery {
    weapon: Uuid,
    team: Teams,
    agent: Option<bool>,
}

pub async fn list_paint_index(
    State(pool): State<PgPool>,
    Query(paint_query): Query<PaintQuery>,
) -> Result<Json<Vec<PaintIndexInfo>>, AppError> {
    let agent = match paint_query.agent {
        Some(agent) => agent,
        None => false,
    };
    let paints = if agent {
        let values = query!("SELECT a.name, a.def_index, a.display, r.color FROM agents a JOIN rarity r ON r.id = a.rarity WHERE a.team=$1", paint_query.team.as_i32()).fetch_all(&pool).await?;
        values
            .into_iter()
            .map(|x| PaintIndexInfo {
                name: x.name,
                paint_index: x.def_index,
                display: x.display,
                color: x.color,
                min_float: 0.0,
                max_float: 0.0,
            })
            .collect()
    } else {
        let category = query!(
            "SELECT w.category FROM weapons w WHERE w.id=$1",
            paint_query.weapon
        )
        .fetch_one(&pool)
        .await?;
        match category.category.as_str() {
            "Knives" | "Gloves" => query_as!(PaintIndexInfo, "SELECT w.name, s.paint_index, s.display, r.color, s.min_float, s.max_float FROM skins s JOIN rarity r ON r.id = s.rarity JOIN weapons w ON w.id = s.weapon WHERE w.category=$1", category.category).fetch_all(&pool).await?,
            _ => query_as!(PaintIndexInfo, "SELECT w.name, s.paint_index, s.display, r.color, s.min_float, s.max_float FROM skins s JOIN rarity r ON r.id = s.rarity JOIN weapons w ON w.id = s.weapon WHERE w.id=$1", paint_query.weapon).fetch_all(&pool).await?
        }
    };
    Ok(Json(paints))
}