import express, { Express, Request, Response } from 'express';
import * as crypto from 'crypto';
import type { SupabaseClient } from '@supabase/supabase-js';
import { Room, Settings } from './types';
import { createSupabase, supabaseConfigured } from './auth_bridge';

/** Per player on the match: deducted when a winner is recorded. */
export const MATCH_ENTRY_FEE_RC = 21;
/** Added to the winning player's RC (after entry fee). */
const MATCH_WINNER_RC_BONUS = 34;
/** Added to each player's CC when a winner is recorded. */
const MATCH_PARTICIPANT_CC_REWARD = 100;

function coerceId(id: unknown): number | null {
    if (id == null) return null;
    if (typeof id === 'bigint') return Number(id);
    if (typeof id === 'number' && Number.isFinite(id)) return id;
    if (typeof id === 'string') {
        const n = parseInt(id, 10);
        return Number.isNaN(n) ? null : n;
    }
    return null;
}

/** Insert a match row when a new room is created. First player in the room = red (if provided). */
export async function insertMatchForNewRoom(settings: Settings, userRedId?: number): Promise<number | null> {
    if (!supabaseConfigured(settings)) return null;
    const supabase = createSupabase(settings);
    const base = { entry_fee: MATCH_ENTRY_FEE_RC };
    const payload = userRedId == null ? base : { ...base, user_red: userRedId };
    const { data, error } = await supabase.from('matches').insert(payload).select('id').single();
    if (error || !data) {
        console.error('matches: insert failed', error?.message);
        return null;
    }
    return coerceId(data.id);
}

/** Dedicated server: rematch row with both players and custom `entry_fee` (RC). */
export async function insertRematchMatch(
    settings: Settings,
    userRedId: number,
    userBlueId: number,
    entryFee: number
): Promise<number | null> {
    if (!supabaseConfigured(settings)) return null;
    const supabase = createSupabase(settings);
    const { data, error } = await supabase
        .from('matches')
        .insert({
            user_red: userRedId,
            user_blue: userBlueId,
            entry_fee: entryFee,
        })
        .select('id')
        .single();
    if (error || !data) {
        console.error('matches: rematch insert failed', error?.message);
        return null;
    }
    return coerceId(data.id);
}

/** Load `username` for two user ids (order not preserved in result). */
export async function loadUsernamesForUserPair(
    settings: Settings,
    userA: number,
    userB: number
): Promise<{ nameById: Map<number, string> } | null> {
    if (!supabaseConfigured(settings)) return null;
    const supabase = createSupabase(settings);
    const { data, error } = await supabase.from('users').select('id, username').in('id', [userA, userB]);
    if (error || !data || data.length !== 2) {
        if (error) console.error('matches: load usernames failed', error.message);
        return null;
    }
    const nameById = new Map<number, string>();
    for (const row of data as { id: unknown; username: unknown }[]) {
        const id = coerceId(row.id);
        if (id == null || typeof row.username !== 'string' || row.username.length < 1) return null;
        nameById.set(id, row.username);
    }
    if (!nameById.has(userA) || !nameById.has(userB)) return null;
    return { nameById };
}

/** Same JSON shape for GET / (room found) and POST /internal/rematch success. */
export type MatchRoomSuccessEnvelope = {
    ok: true;
    entry_fee: number;
    for_red: Room | null;
    for_blue: Room | null;
};

export type CreateRematchRoomResult = MatchRoomSuccessEnvelope | { ok: false; status: number; error: string };

export type CreateRematchRoomFn = (args: {
    userRedId: number;
    userBlueId: number;
    entryFee: number;
}) => Promise<CreateRematchRoomResult>;

/** Latest 10 matches for this user (by created_at); counts wins/losses from winner_id only. */
export async function getPlayerLast10MatchRecord(
    settings: Settings,
    playerId: number
): Promise<{ l10_wins: number; l10_losses: number }> {
    if (!supabaseConfigured(settings)) {
        return { l10_wins: 0, l10_losses: 0 };
    }
    const supabase = createSupabase(settings);
    const { data, error } = await supabase
        .from('matches')
        .select('winner_id')
        .or(`user_red.eq.${playerId},user_blue.eq.${playerId}`)
        .order('created_at', { ascending: false })
        .limit(10);

    if (error || !data) {
        console.error('matches: last10 fetch failed', error?.message);
        return { l10_wins: 0, l10_losses: 0 };
    }

    let l10_wins = 0;
    let l10_losses = 0;
    for (const row of data as { winner_id: unknown }[]) {
        const wid = coerceId(row.winner_id);
        if (wid == null) continue;
        if (wid === playerId) l10_wins++;
        else l10_losses++;
    }
    return { l10_wins, l10_losses };
}

/**
 * Entry fee from each participant, winner bonus RC, CC for both. Idempotent callers should set winner only once.
 */
async function applyMatchWinnerEconomy(
    supabase: SupabaseClient,
    userRed: number | null,
    userBlue: number | null,
    winnerId: number
): Promise<string | null> {
    const ids = [...new Set([userRed, userBlue].filter((x): x is number => x != null && x >= 1))];
    if (ids.length === 0) return null;

    const { data: rows, error: selErr } = await supabase.from('users').select('id, rc, cc').in('id', ids);
    if (selErr) return selErr.message;
    if (!rows || rows.length !== ids.length) return 'One or more players not found in users';

    for (const row of rows) {
        const uid = coerceId((row as { id: unknown }).id);
        if (uid == null) continue;
        const baseRc = Number((row as { rc: unknown }).rc ?? 0);
        const baseCc = Number((row as { cc: unknown }).cc ?? 0);
        let newRc = baseRc - MATCH_ENTRY_FEE_RC;
        if (uid === winnerId) newRc += MATCH_WINNER_RC_BONUS;
        const newCc = baseCc + MATCH_PARTICIPANT_CC_REWARD;
        const { error: upErr } = await supabase.from('users').update({ rc: newRc, cc: newCc }).eq('id', uid);
        if (upErr) return upErr.message;
    }
    return null;
}

/** Second player joining the room = blue. */
export async function updateMatchUserBlue(settings: Settings, matchId: number, userBlueId: number): Promise<void> {
    if (!supabaseConfigured(settings)) return;
    const supabase = createSupabase(settings);
    const { error } = await supabase.from('matches').update({ user_blue: userBlueId }).eq('id', matchId);
    if (error) {
        console.error('matches: update user_blue failed', error.message);
    }
}

function dedicatedServerConfigured(settings: Settings): boolean {
    return Boolean(settings.dedicated_server_secret?.trim());
}

function timingSafeEqualStr(a: string, b: string): boolean {
    try {
        const ba = Buffer.from(a, 'utf8');
        const bb = Buffer.from(b, 'utf8');
        if (ba.length !== bb.length) return false;
        return crypto.timingSafeEqual(ba, bb);
    } catch {
        return false;
    }
}

/** If true, response already sent — handler must return. */
function rejectUnlessDedicatedServer(req: Request, res: Response, settings: Settings): boolean {
    if (!supabaseConfigured(settings)) {
        res.status(503).json({ ok: false, error: 'Database not configured' });
        return true;
    }
    if (!dedicatedServerConfigured(settings)) {
        res.status(503).json({ ok: false, error: 'dedicated_server_secret not set in settings' });
        return true;
    }
    const hdr = req.headers['x-dedicated-server-secret'];
    const expected = settings.dedicated_server_secret!.trim();
    if (typeof hdr !== 'string' || !timingSafeEqualStr(hdr, expected)) {
        res.status(403).json({ ok: false, error: 'Forbidden' });
        return true;
    }
    return false;
}

export function registerMatchRoutes(
    app: Express,
    settings: Settings,
    deps?: { createRematchRoom?: CreateRematchRoomFn }
): void {
    const jsonParser = express.json();

    /**
     * Public: last-10 match record for a player (`users.id` / matchmaking UserId).
     * Wins/losses from the latest 10 `matches` rows where the player is red or blue.
     */
    app.get('/players/:playerId/l10', async (req: Request, res: Response) => {
        if (!supabaseConfigured(settings)) {
            res.status(503).json({ ok: false, error: 'Database not configured' });
            return;
        }
        const playerId = coerceId(req.params.playerId);
        if (playerId == null || playerId < 1) {
            res.status(400).json({ ok: false, error: 'Invalid player id' });
            return;
        }
        const l10 = await getPlayerLast10MatchRecord(settings, playerId);
        res.json({
            ok: true,
            player_id: playerId,
            l10_wins: l10.l10_wins,
            l10_losses: l10.l10_losses,
        });
    });

    /** Public: RC balance for a player (`users.id` / matchmaking UserId). */
    app.get('/players/:playerId/rc', async (req: Request, res: Response) => {
        if (!supabaseConfigured(settings)) {
            res.status(503).json({ ok: false, error: 'Database not configured' });
            return;
        }
        const playerId = coerceId(req.params.playerId);
        if (playerId == null || playerId < 1) {
            res.status(400).json({ ok: false, error: 'Invalid player id' });
            return;
        }
        const supabase = createSupabase(settings);
        const { data, error } = await supabase.from('users').select('rc').eq('id', playerId).maybeSingle();
        if (error) {
            res.status(500).json({ ok: false, error: error.message });
            return;
        }
        if (!data) {
            res.status(404).json({ ok: false, error: 'Player not found' });
            return;
        }
        const rc = Number((data as { rc: unknown }).rc ?? 0);
        res.json({ ok: true, player_id: playerId, rc });
    });

    /**
     * Dedicated server only: open a room with two players and a custom RC entry fee.
     * Response body matches GET / on room success: `{ ok, entry_fee, for_red, for_blue }`.
     */
    app.post('/internal/rematch', jsonParser, async (req: Request, res: Response) => {
        if (rejectUnlessDedicatedServer(req, res, settings)) return;
        if (!deps?.createRematchRoom) {
            res.status(503).json({ ok: false, error: 'Rematch handler not configured' });
            return;
        }

        const body = req.body as Record<string, unknown>;
        const userRedId = coerceId(body.user_red_id);
        const userBlueId = coerceId(body.user_blue_id);
        const rawFee = body.entry_fee;
        const entryFee =
            typeof rawFee === 'bigint'
                ? Number(rawFee)
                : typeof rawFee === 'number' && Number.isFinite(rawFee)
                  ? Math.trunc(rawFee)
                  : typeof rawFee === 'string' && /^-?\d+$/.test(rawFee.trim())
                    ? parseInt(rawFee.trim(), 10)
                    : null;

        if (userRedId == null || userRedId < 1 || userBlueId == null || userBlueId < 1) {
            res.status(400).json({ ok: false, error: 'user_red_id and user_blue_id must be positive integers' });
            return;
        }
        if (userRedId === userBlueId) {
            res.status(400).json({ ok: false, error: 'user_red_id and user_blue_id must differ' });
            return;
        }
        if (entryFee == null || !Number.isInteger(entryFee) || entryFee < 0) {
            res.status(400).json({ ok: false, error: 'entry_fee must be a non-negative integer' });
            return;
        }

        const result = await deps.createRematchRoom({ userRedId, userBlueId, entryFee });
        if (!result.ok) {
            res.status(result.status).json({ ok: false, error: result.error });
            return;
        }
        res.json(result);
    });

    app.patch('/internal/match/:matchId', jsonParser, async (req: Request, res: Response) => {
        if (rejectUnlessDedicatedServer(req, res, settings)) return;

        const matchId = coerceId(req.params.matchId);
        if (matchId == null || matchId < 1) {
            res.status(400).json({ ok: false, error: 'Invalid match id' });
            return;
        }

        const body = req.body as Record<string, unknown>;
        const patch: Record<string, string | number | null> = {};

        if (Object.prototype.hasOwnProperty.call(body, 'red_joined_at')) {
            const v = body.red_joined_at;
            if (v === null) patch.red_joined_at = null;
            else if (typeof v === 'string') patch.red_joined_at = v;
            else {
                res.status(400).json({ ok: false, error: 'red_joined_at must be ISO string or null' });
                return;
            }
        }
        if (Object.prototype.hasOwnProperty.call(body, 'blue_joined_at')) {
            const v = body.blue_joined_at;
            if (v === null) patch.blue_joined_at = null;
            else if (typeof v === 'string') patch.blue_joined_at = v;
            else {
                res.status(400).json({ ok: false, error: 'blue_joined_at must be ISO string or null' });
                return;
            }
        }
        if (Object.prototype.hasOwnProperty.call(body, 'status')) {
            const v = body.status;
            if (v === null) patch.status = null;
            else if (typeof v === 'number' && Number.isInteger(v)) patch.status = v;
            else if (typeof v === 'string' && /^-?\d+$/.test(v)) patch.status = parseInt(v, 10);
            else {
                res.status(400).json({ ok: false, error: 'status must be integer or null' });
                return;
            }
        }

        if (Object.keys(patch).length === 0) {
            res.status(400).json({ ok: false, error: 'Body must include at least one of red_joined_at, blue_joined_at, status' });
            return;
        }

        const supabase = createSupabase(settings);
        const { data, error } = await supabase.from('matches').update(patch).eq('id', matchId).select('id').maybeSingle();

        if (error) {
            res.status(500).json({ ok: false, error: error.message });
            return;
        }
        if (!data) {
            res.status(404).json({ ok: false, error: 'Match not found' });
            return;
        }
        res.json({ ok: true, id: matchId });
    });

    /** Unity dedicated server: set `winner_id` from match sides (`user_red` / `user_blue`). */
    app.patch('/internal/match/:matchId/winner', jsonParser, async (req: Request, res: Response) => {
        if (rejectUnlessDedicatedServer(req, res, settings)) return;

        const matchId = coerceId(req.params.matchId);
        if (matchId == null || matchId < 1) {
            res.status(400).json({ ok: false, error: 'Invalid match id' });
            return;
        }

        const body = req.body as Record<string, unknown>;
        const side = body.winner;
        if (side !== 'red' && side !== 'blue') {
            res.status(400).json({ ok: false, error: 'Body must include winner: "red" | "blue"' });
            return;
        }

        const supabase = createSupabase(settings);
        const { data: row, error: fetchErr } = await supabase
            .from('matches')
            .select('user_red, user_blue')
            .eq('id', matchId)
            .maybeSingle();

        if (fetchErr) {
            res.status(500).json({ ok: false, error: fetchErr.message });
            return;
        }
        if (!row) {
            res.status(404).json({ ok: false, error: 'Match not found' });
            return;
        }

        const userRed = coerceId((row as { user_red: unknown }).user_red);
        const userBlue = coerceId((row as { user_blue: unknown }).user_blue);
        const winnerId = side === 'red' ? userRed : userBlue;
        if (winnerId == null) {
            res.status(400).json({ ok: false, error: `${side} slot has no user on this match` });
            return;
        }

        const { data: updated, error: updErr } = await supabase
            .from('matches')
            .update({ winner_id: winnerId })
            .eq('id', matchId)
            .is('winner_id', null)
            .select('id')
            .maybeSingle();

        if (updErr) {
            res.status(500).json({ ok: false, error: updErr.message });
            return;
        }
        if (!updated) {
            const { data: existing } = await supabase.from('matches').select('id').eq('id', matchId).maybeSingle();
            if (!existing) {
                res.status(404).json({ ok: false, error: 'Match not found' });
                return;
            }
            res.status(409).json({ ok: false, error: 'Winner already set for this match' });
            return;
        }

        const payErr = await applyMatchWinnerEconomy(supabase, userRed, userBlue, winnerId);
        if (payErr != null) {
            console.error('matches: economy after winner failed', matchId, payErr);
            await supabase.from('matches').update({ winner_id: null }).eq('id', matchId).eq('winner_id', winnerId);
            res.status(500).json({ ok: false, error: `Economy update failed: ${payErr}` });
            return;
        }

        res.json({
            ok: true,
            id: matchId,
            winner_id: winnerId,
            economy: {
                entry_fee_rc: MATCH_ENTRY_FEE_RC,
                winner_rc_bonus: MATCH_WINNER_RC_BONUS,
                participant_cc: MATCH_PARTICIPANT_CC_REWARD,
            },
        });
    });
}