use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    Json,
};
use serde::{Deserialize, Serialize};
use sqlx::FromRow;

use crate::{
    auth::AuthUser,
    error::{AppError, Result},
};

use super::auth::AppState;

// ============================================================================
// Request/Response Types
// ============================================================================

#[derive(Debug, Deserialize, Default)]
pub struct ListPlayersQuery {
    pub search: Option<String>,
    pub page: Option<i64>,
    pub per_page: Option<i64>,
    pub sort_by: Option<String>, // "mmr", "username", "date_registered"
    pub sort_order: Option<String>, // "asc", "desc"
}

#[derive(Debug, Serialize)]
pub struct PlayerListResponse {
    pub players: Vec<PlayerSummary>,
    pub total: i64,
    pub page: i64,
    pub per_page: i64,
}

#[derive(Debug, Serialize, FromRow)]
pub struct PlayerSummary {
    pub id: i32,
    pub username: String,
    pub firstname: String,
    pub lastname: String,
    pub profile: Option<String>,
    pub date_registered: chrono::DateTime<chrono::Utc>,
    pub team_id: Option<i32>,
    pub team_name: Option<String>,
    pub team_position: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct PlayerProfileResponse {
    pub id: i32,
    pub username: String,
    pub firstname: String,
    pub lastname: String,
    pub profile: Option<String>,
    pub date_registered: chrono::DateTime<chrono::Utc>,
    pub is_admin: bool,
    pub mu: f32,
    pub sigma: f32,
    pub ordinal: f32,
    pub mmr: f32,
    pub team: Option<PlayerTeamInfo>,
    pub stats: PlayerStats,
    pub recent_matches: Vec<PlayerMatchSummary>,
}

#[derive(Debug, Serialize)]
pub struct PlayerTeamInfo {
    pub id: i32,
    pub name: String,
    pub logo: String,
    pub position: String,
    pub date_joined: chrono::DateTime<chrono::Utc>,
}

#[derive(Debug, Serialize)]
pub struct PlayerStats {
    pub matches_played: i64,
    pub matches_won: i64,
    pub matches_lost: i64,
    pub win_rate: f32,
    pub ladders_participated: i64,
    // OpenSkill rating stats
    pub mu: f64,
    pub sigma: f64,
    pub ordinal: f64,
    pub mmr: f64,
}

#[derive(Debug, Serialize, FromRow)]
pub struct PlayerMatchSummary {
    pub match_id: i32,
    pub date_played: chrono::DateTime<chrono::Utc>,
    pub opponent_team_name: String,
    pub own_team_name: String,
    pub own_score: i32,
    pub opponent_score: i32,
    pub result: String, // "win", "loss", "draw"
}

#[derive(Debug, Serialize)]
pub struct FeaturedPlayersResponse {
    pub players: Vec<FeaturedPlayerInfo>,
}

#[derive(Debug, Serialize, FromRow)]
pub struct FeaturedPlayerInfo {
    pub id: i32,
    pub player_id: i32,
    pub rank: i32,
    pub username: String,
    pub firstname: String,
    pub lastname: String,
    pub profile: Option<String>,
    pub team_name: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct SetFeaturedPlayerRequest {
    pub player_id: i32,
    pub rank: i32,
}

#[derive(Debug, Serialize)]
pub struct LeaderboardResponse {
    pub players: Vec<LeaderboardEntry>,
    pub total: i64,
    pub page: i64,
    pub per_page: i64,
}

#[derive(Debug, Serialize, FromRow)]
pub struct LeaderboardEntry {
    pub rank: i64,
    pub player_id: i32,
    pub username: String,
    pub firstname: String,
    pub lastname: String,
    pub profile: Option<String>,
    pub team_name: Option<String>,
    pub matches_won: Option<i64>,
    pub matches_played: Option<i64>,
}

// ============================================================================
// Handlers
// ============================================================================

/// GET /api/players
/// List all players with pagination and search
pub async fn list_players(
    Query(query): Query<ListPlayersQuery>,
    State(state): State<AppState>,
) -> Result<Json<PlayerListResponse>> {
    let page = query.page.unwrap_or(1).max(1);
    let per_page = query.per_page.unwrap_or(20).clamp(1, 100);
    let offset = (page - 1) * per_page;

    let search_pattern = query.search.as_ref().map(|s| format!("%{}%", s));

    // Determine sort order
    let sort_column = match query.sort_by.as_deref() {
        Some("username") => "u.username",
        Some("date_registered") => "u.date_registered",
        _ => "u.date_registered",
    };
    let sort_order = match query.sort_order.as_deref() {
        Some("asc") => "ASC",
        _ => "DESC",
    };

    let (total, players): (i64, Vec<PlayerSummary>) = if let Some(ref pattern) = search_pattern {
        let total = sqlx::query_scalar(
            "SELECT COUNT(*) FROM users WHERE username ILIKE $1 OR firstname ILIKE $1 OR lastname ILIKE $1"
        )
        .bind(pattern)
        .fetch_one(&state.pool)
        .await?;

        let query_str = format!(
            r#"
            SELECT u.id, u.username, u.firstname, u.lastname, u.profile, u.date_registered,
                   tp.team_id, t.name as team_name, tp.position as team_position
            FROM users u
            LEFT JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
            LEFT JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
            WHERE u.username ILIKE $1 OR u.firstname ILIKE $1 OR u.lastname ILIKE $1
            ORDER BY {} {}
            LIMIT $2 OFFSET $3
            "#,
            sort_column, sort_order
        );

        let players = sqlx::query_as(&query_str)
            .bind(pattern)
            .bind(per_page)
            .bind(offset)
            .fetch_all(&state.pool)
            .await?;

        (total, players)
    } else {
        let total = sqlx::query_scalar("SELECT COUNT(*) FROM users")
            .fetch_one(&state.pool)
            .await?;

        let query_str = format!(
            r#"
            SELECT u.id, u.username, u.firstname, u.lastname, u.profile, u.date_registered,
                   tp.team_id, t.name as team_name, tp.position as team_position
            FROM users u
            LEFT JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
            LEFT JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
            ORDER BY {} {}
            LIMIT $1 OFFSET $2
            "#,
            sort_column, sort_order
        );

        let players = sqlx::query_as(&query_str)
            .bind(per_page)
            .bind(offset)
            .fetch_all(&state.pool)
            .await?;

        (total, players)
    };

    Ok(Json(PlayerListResponse {
        players,
        total,
        page,
        per_page,
    }))
}

/// GET /api/players/:id
/// Get player profile with stats
pub async fn get_player(
    State(state): State<AppState>,
    Path(player_id): Path<i32>,
) -> Result<Json<PlayerProfileResponse>> {
    // Get basic player info including OpenSkill ratings
    let player = sqlx::query_as::<_, (i32, String, String, String, Option<String>, chrono::DateTime<chrono::Utc>, bool, Option<f32>, Option<f32>, Option<f32>, Option<f32>)>(
        "SELECT id, username, firstname, lastname, profile, date_registered, is_admin, mu, sigma, ordinal, mmr FROM users WHERE id = $1"
    )
    .bind(player_id)
    .fetch_optional(&state.pool)
    .await?
    .ok_or_else(|| AppError::NotFound("Player not found".to_string()))?;

    // Get team info
    let team_info = sqlx::query_as::<_, (i32, String, String, String, chrono::DateTime<chrono::Utc>)>(
        r#"
        SELECT t.id, t.name, t.logo, tp.position, tp.date_created
        FROM team_players tp
        JOIN teams t ON tp.team_id = t.id
        WHERE tp.player_id = $1 AND tp.status = 1 AND t.is_delete = false
        "#
    )
    .bind(player_id)
    .fetch_optional(&state.pool)
    .await?;

    let team = team_info.map(|(id, name, logo, position, date_joined)| PlayerTeamInfo {
        id,
        name,
        logo,
        position,
        date_joined,
    });

    // Get match stats
    let stats = get_player_stats(&state.pool, player_id, team.as_ref().map(|t| t.id)).await?;

    // Get recent matches
    let recent_matches = if let Some(ref t) = team {
        get_recent_matches(&state.pool, t.id, 5).await?
    } else {
        vec![]
    };

    Ok(Json(PlayerProfileResponse {
        id: player.0,
        username: player.1,
        firstname: player.2,
        lastname: player.3,
        profile: player.4,
        date_registered: player.5,
        is_admin: player.6,
        mu: player.7.unwrap_or(25.0),
        sigma: player.8.unwrap_or(8.333),
        ordinal: player.9.unwrap_or(0.0),
        mmr: player.10.unwrap_or(1000.0),
        team,
        stats,
        recent_matches,
    }))
}

/// GET /api/players/featured
/// Get featured players
pub async fn get_featured_players(
    State(state): State<AppState>,
) -> Result<Json<FeaturedPlayersResponse>> {
    let players = sqlx::query_as::<_, FeaturedPlayerInfo>(
        r#"
        SELECT fp.id, fp.player_id, fp.rank, u.username, u.firstname, u.lastname, u.profile, t.name as team_name
        FROM featured_players fp
        JOIN users u ON fp.player_id = u.id
        LEFT JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
        LEFT JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
        ORDER BY fp.rank ASC
        "#
    )
    .fetch_all(&state.pool)
    .await?;

    Ok(Json(FeaturedPlayersResponse { players }))
}

/// POST /api/players/featured
/// Add/update featured player (admin only)
pub async fn set_featured_player(
    user: AuthUser,
    State(state): State<AppState>,
    Json(payload): Json<SetFeaturedPlayerRequest>,
) -> Result<(StatusCode, Json<FeaturedPlayerInfo>)> {
    if !user.is_admin {
        return Err(AppError::Forbidden("Only admins can manage featured players".to_string()));
    }

    // Verify player exists
    let player_exists = sqlx::query_scalar::<_, i32>(
        "SELECT id FROM users WHERE id = $1"
    )
    .bind(payload.player_id)
    .fetch_optional(&state.pool)
    .await?;

    if player_exists.is_none() {
        return Err(AppError::NotFound("Player not found".to_string()));
    }

    // Upsert featured player
    sqlx::query(
        r#"
        INSERT INTO featured_players (player_id, rank)
        VALUES ($1, $2)
        ON CONFLICT (player_id) DO UPDATE SET rank = $2
        "#
    )
    .bind(payload.player_id)
    .bind(payload.rank)
    .execute(&state.pool)
    .await?;

    // Fetch the full featured player info
    let featured = sqlx::query_as::<_, FeaturedPlayerInfo>(
        r#"
        SELECT fp.id, fp.player_id, fp.rank, u.username, u.firstname, u.lastname, u.profile, t.name as team_name
        FROM featured_players fp
        JOIN users u ON fp.player_id = u.id
        LEFT JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
        LEFT JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
        WHERE fp.player_id = $1
        "#
    )
    .bind(payload.player_id)
    .fetch_one(&state.pool)
    .await?;

    Ok((StatusCode::CREATED, Json(featured)))
}

/// DELETE /api/players/featured/:player_id
/// Remove featured player (admin only)
pub async fn remove_featured_player(
    user: AuthUser,
    State(state): State<AppState>,
    Path(player_id): Path<i32>,
) -> Result<StatusCode> {
    if !user.is_admin {
        return Err(AppError::Forbidden("Only admins can manage featured players".to_string()));
    }

    let result = sqlx::query("DELETE FROM featured_players WHERE player_id = $1")
        .bind(player_id)
        .execute(&state.pool)
        .await?;

    if result.rows_affected() == 0 {
        return Err(AppError::NotFound("Featured player not found".to_string()));
    }

    Ok(StatusCode::NO_CONTENT)
}

/// GET /api/players/leaderboard
/// Get player leaderboard (by match wins)
pub async fn get_leaderboard(
    Query(query): Query<ListPlayersQuery>,
    State(state): State<AppState>,
) -> Result<Json<LeaderboardResponse>> {
    let page = query.page.unwrap_or(1).max(1);
    let per_page = query.per_page.unwrap_or(20).clamp(1, 100);
    let offset = (page - 1) * per_page;

    // Count total players with at least one match
    let total: i64 = sqlx::query_scalar(
        r#"
        SELECT COUNT(DISTINCT u.id)
        FROM users u
        JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
        JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
        JOIN (
            SELECT team_id_1 as team_id FROM matches WHERE matche_status = 3
            UNION ALL
            SELECT team_id_2 FROM matches WHERE matche_status = 3
        ) m ON t.id = m.team_id
        "#
    )
    .fetch_one(&state.pool)
    .await
    .unwrap_or(0);

    // Get leaderboard with match stats
    let players = sqlx::query_as::<_, LeaderboardEntry>(
        r#"
        WITH player_matches AS (
            SELECT 
                u.id as player_id,
                u.username,
                u.firstname,
                u.lastname,
                u.profile,
                t.name as team_name,
                t.id as team_id
            FROM users u
            JOIN team_players tp ON u.id = tp.player_id AND tp.status = 1
            JOIN teams t ON tp.team_id = t.id AND t.is_delete = false
        ),
        match_results AS (
            SELECT 
                pm.player_id,
                COUNT(DISTINCT m.id) as matches_played,
                COUNT(DISTINCT CASE 
                    WHEN (m.team_id_1 = pm.team_id AND mr.team_1_score > mr.team_2_score)
                      OR (m.team_id_2 = pm.team_id AND mr.team_2_score > mr.team_1_score)
                    THEN m.id 
                END) as matches_won
            FROM player_matches pm
            LEFT JOIN matches m ON (m.team_id_1 = pm.team_id OR m.team_id_2 = pm.team_id) 
                AND m.matche_status = 3
            LEFT JOIN match_rounds mr ON m.id = mr.match_id AND mr.score_acceptance_status = 1
            GROUP BY pm.player_id
        )
        SELECT 
            ROW_NUMBER() OVER (ORDER BY COALESCE(mr.matches_won, 0) DESC, pm.username ASC) as rank,
            pm.player_id,
            pm.username,
            pm.firstname,
            pm.lastname,
            pm.profile,
            pm.team_name,
            mr.matches_won,
            mr.matches_played
        FROM player_matches pm
        LEFT JOIN match_results mr ON pm.player_id = mr.player_id
        ORDER BY COALESCE(mr.matches_won, 0) DESC, pm.username ASC
        LIMIT $1 OFFSET $2
        "#
    )
    .bind(per_page)
    .bind(offset)
    .fetch_all(&state.pool)
    .await?;

    Ok(Json(LeaderboardResponse {
        players,
        total,
        page,
        per_page,
    }))
}

// ============================================================================
// Helper Functions
// ============================================================================

async fn get_player_stats(
    pool: &sqlx::PgPool,
    player_id: i32,
    team_id: Option<i32>,
) -> Result<PlayerStats> {
    // Get player's OpenSkill rating
    let rating: (Option<f32>, Option<f32>, Option<f32>, Option<f32>) = sqlx::query_as(
        "SELECT mu, sigma, ordinal, mmr FROM users WHERE id = $1"
    )
    .bind(player_id)
    .fetch_one(pool)
    .await
    .unwrap_or((None, None, None, None));
    
    let mu = rating.0.unwrap_or(25.0) as f64;
    let sigma = rating.1.unwrap_or(8.333333) as f64;
    let ordinal = rating.2.unwrap_or(0.0) as f64;
    let mmr = rating.3.unwrap_or(1500.0) as f64;
    
    let Some(team_id) = team_id else {
        return Ok(PlayerStats {
            matches_played: 0,
            matches_won: 0,
            matches_lost: 0,
            win_rate: 0.0,
            ladders_participated: 0,
            mu,
            sigma,
            ordinal,
            mmr,
        });
    };

    // Count completed matches
    let matches_played: i64 = sqlx::query_scalar(
        r#"
        SELECT COUNT(*) FROM matches 
        WHERE (team_id_1 = $1 OR team_id_2 = $1) AND matche_status = 3
        "#
    )
    .bind(team_id)
    .fetch_one(pool)
    .await
    .unwrap_or(0);

    // Count wins (based on accepted scores)
    let matches_won: i64 = sqlx::query_scalar(
        r#"
        SELECT COUNT(DISTINCT m.id) FROM matches m
        JOIN match_rounds mr ON m.id = mr.match_id AND mr.score_acceptance_status = 1
        WHERE m.matche_status = 3
        AND (
            (m.team_id_1 = $1 AND mr.team_1_score > mr.team_2_score)
            OR (m.team_id_2 = $1 AND mr.team_2_score > mr.team_1_score)
        )
        "#
    )
    .bind(team_id)
    .fetch_one(pool)
    .await
    .unwrap_or(0);

    let matches_lost = matches_played - matches_won;
    let win_rate = if matches_played > 0 {
        (matches_won as f32 / matches_played as f32) * 100.0
    } else {
        0.0
    };

    // Count ladders participated
    let ladders_participated: i64 = sqlx::query_scalar(
        "SELECT COUNT(*) FROM ladder_teams WHERE team_id = $1"
    )
    .bind(team_id)
    .fetch_one(pool)
    .await
    .unwrap_or(0);

    Ok(PlayerStats {
        matches_played,
        matches_won,
        matches_lost,
        win_rate,
        ladders_participated,
        mu,
        sigma,
        ordinal,
        mmr,
    })
}

async fn get_recent_matches(
    pool: &sqlx::PgPool,
    team_id: i32,
    limit: i64,
) -> Result<Vec<PlayerMatchSummary>> {
    let matches = sqlx::query_as::<_, PlayerMatchSummary>(
        r#"
        SELECT 
            m.id as match_id,
            m.date_start as date_played,
            CASE WHEN m.team_id_1 = $1 THEN t2.name ELSE t1.name END as opponent_team_name,
            CASE WHEN m.team_id_1 = $1 THEN t1.name ELSE t2.name END as own_team_name,
            CASE WHEN m.team_id_1 = $1 THEN COALESCE(mr.team_1_score, 0) ELSE COALESCE(mr.team_2_score, 0) END as own_score,
            CASE WHEN m.team_id_1 = $1 THEN COALESCE(mr.team_2_score, 0) ELSE COALESCE(mr.team_1_score, 0) END as opponent_score,
            CASE 
                WHEN mr.id IS NULL THEN 'pending'
                WHEN m.team_id_1 = $1 AND mr.team_1_score > mr.team_2_score THEN 'win'
                WHEN m.team_id_2 = $1 AND mr.team_2_score > mr.team_1_score THEN 'win'
                WHEN mr.team_1_score = mr.team_2_score THEN 'draw'
                ELSE 'loss'
            END as result
        FROM matches m
        JOIN teams t1 ON m.team_id_1 = t1.id
        JOIN teams t2 ON m.team_id_2 = t2.id
        LEFT JOIN match_rounds mr ON m.id = mr.match_id AND mr.score_acceptance_status = 1
        WHERE (m.team_id_1 = $1 OR m.team_id_2 = $1) AND m.matche_status = 3
        ORDER BY m.date_start DESC
        LIMIT $2
        "#
    )
    .bind(team_id)
    .bind(limit)
    .fetch_all(pool)
    .await?;

    Ok(matches)
}

// Note: Profile upload is now handled by uploads.rs using multipart forms

/// GET /api/players/rating-history/:player_id
/// Get a player's rating history
pub async fn get_rating_history(
    State(state): State<AppState>,
    Path(player_id): Path<i32>,
) -> Result<Json<Vec<RatingHistoryEntry>>> {
    let history = sqlx::query_as::<_, RatingHistoryEntry>(
        r#"
        SELECT 
            rh.id, rh.date_created, rh.match_id,
            rh.old_mu, rh.old_sigma, rh.old_ordinal,
            rh.new_mu, rh.new_sigma, rh.new_ordinal,
            t1.name as opponent_name
        FROM rating_history rh
        LEFT JOIN matches m ON rh.match_id = m.id
        LEFT JOIN teams t1 ON (
            CASE 
                WHEN m.team_id_1 IN (SELECT tp.team_id FROM team_players tp WHERE tp.player_id = $1 AND tp.status = 1)
                THEN m.team_id_2
                ELSE m.team_id_1
            END = t1.id
        )
        WHERE rh.entity_type = 'player' AND rh.entity_id = $1
        ORDER BY rh.date_created DESC
        LIMIT 50
        "#
    )
    .bind(player_id)
    .fetch_all(&state.pool)
    .await?;

    Ok(Json(history))
}

#[derive(Debug, Serialize, FromRow)]
pub struct RatingHistoryEntry {
    pub id: i32,
    pub date_created: chrono::DateTime<chrono::Utc>,
    pub match_id: Option<i32>,
    pub old_mu: f64,
    pub old_sigma: f64,
    pub old_ordinal: f64,
    pub new_mu: f64,
    pub new_sigma: f64,
    pub new_ordinal: f64,
    pub opponent_name: Option<String>,
}