//! Regression tests for the server-side 5x3 slots game.

use zagan_bet::slots::{paytable_lines, PAYTABLE};
use zagan_bet::server::games::slots::{LineWin, SlotsGame, PAYLINES, REELS, ROWS};
use zagan_bet::server::games::traits::{Game, GamePhase};

/// Convert row-major test rows into the column-major wire format.
fn grid(rows: [&str; 3]) -> String {
    let cells: Vec<Vec<char>> = rows.iter().map(|row| row.chars().collect()).collect();
    let mut result = String::new();
    for col in 0..REELS {
        for row in 0..ROWS {
            result.push(cells[row][col]);
        }
    }
    result
}

fn payout(rows: [&str; 3], bet: u64) -> (u64, Vec<LineWin>) {
    let reels = grid(rows);
    let game = SlotsGame::with_grid(&reels);
    let cells: Vec<char> = reels.chars().collect();
    game.calculate_payout(&cells, bet)
}

fn lines(wins: &[LineWin]) -> Vec<usize> {
    wins.iter().map(|win| win.line).collect()
}

#[test]
fn the_wire_grid_is_five_reels_by_three_rows() {
    assert_eq!(REELS, 5);
    assert_eq!(ROWS, 3);
    assert_eq!(PAYLINES.len(), 5);

    let game = SlotsGame::new();
    let state = game.prepare_state("alice", 10);
    let state = game.process_action(&state, "spin", &[]).unwrap();
    let reels = state.data.get("reels").unwrap();
    assert_eq!(reels.chars().count(), REELS * ROWS);
}

#[test]
fn three_of_a_kind_on_the_top_line_pays() {
    let (winnings, wins) = payout(["CCCDD", "CLLGG", "CLOSS"], 10);

    assert_eq!(winnings, 20, "CCC on line 1 pays 2x total bet");
    assert_eq!(lines(&wins), vec![1]);
    assert_eq!(wins[0].cells, vec![0, 3, 6]);
}

#[test]
fn four_of_a_kind_pays_more_than_three() {
    let (winnings, wins) = payout(["CCCCD", "LOGDS", "OGDSL"], 10);

    assert_eq!(winnings, 50, "CCCC pays 5x total bet");
    assert_eq!(lines(&wins), vec![1]);
    assert_eq!(wins[0].cells, vec![0, 3, 6, 9]);
}

#[test]
fn five_of_a_kind_pays_all_lines() {
    let (winnings, wins) = payout(["SSSSS", "SSSSS", "SSSSS"], 10);

    assert_eq!(winnings, 7500, "five SSSSS lines at 150x each");
    assert_eq!(lines(&wins), vec![1, 2, 3, 4, 5]);
    assert_eq!(wins[0].cells, vec![0, 3, 6, 9, 12]);
    assert_eq!(wins[3].cells, vec![0, 4, 8, 10, 12]);
    assert_eq!(wins[4].cells, vec![2, 4, 6, 10, 14]);
}

#[test]
fn the_v_payline_is_evaluated() {
    let (winnings, wins) = payout(["COGDC", "LCLCG", "OGCSD"], 10);

    assert_eq!(winnings, 150, "V line with five C symbols pays 15x");
    assert_eq!(lines(&wins), vec![4]);
    assert_eq!(wins[0].cells, vec![0, 4, 8, 10, 12]);
}

#[test]
fn no_matching_line_pays_nothing() {
    let (winnings, wins) = payout(["CLOGD", "LOSGC", "DGDSC"], 100);

    assert_eq!(winnings, 0);
    assert!(wins.is_empty());
}

#[test]
fn winning_lines_are_added_together() {
    let (winnings, wins) = payout(["SSSSS", "LLLLL", "OOOOO"], 10);

    assert_eq!(winnings, (150 + 20 + 25) * 10);
    assert_eq!(lines(&wins), vec![1, 2, 3]);

    let mut cells: Vec<usize> = wins.iter().flat_map(|win| win.cells.clone()).collect();
    cells.sort_unstable();
    assert_eq!(cells, (0..15).collect::<Vec<_>>());
}

#[test]
fn theoretical_rtp_is_just_under_one() {
    let rtp = SlotsGame::new().theoretical_rtp();

    assert!((rtp - 425.0 / 432.0).abs() < 1e-12);
    assert!(rtp < 1.0, "house edge must be positive");
    assert!(rtp > 0.98, "house edge should be tiny");
}

#[test]
fn the_paytable_lines_list_every_symbol_and_fit_80_columns() {
    let lines = paytable_lines();
    let joined = lines.join(" ");

    assert_eq!(lines.len(), 2, "paytable should be split into two lines");
    for (symbol, three, four, five) in PAYTABLE {
        assert!(
            joined.contains(&format!("{symbol} {three}/{four}/{five}")),
            "paytable is missing {symbol}"
        );
    }
    for line in lines {
        assert!(line.len() <= 80, "paytable is too wide: {line:?}");
    }
}

#[test]
fn an_enormous_bet_saturates_instead_of_overflowing() {
    let (winnings, _) = payout(["SSSSS", "SSSSS", "SSSSS"], u64::MAX);

    assert_eq!(winnings, u64::MAX);
}

#[test]
fn a_spin_produces_a_finished_state_and_a_result_with_win_lines() {
    let game = SlotsGame::with_grid(&grid(["CCCDD", "CLLGG", "CLOSS"]));
    let state = game.prepare_state("alice", 10);

    let state = game.process_action(&state, "spin", &[]).unwrap();
    assert_eq!(state.phase, GamePhase::Finished);

    let result = game.calculate_result(&state).unwrap();
    assert_eq!(result.winnings, 20);
    assert_eq!(result.result_data.get("win_type").unwrap(), "win");
    assert_eq!(result.result_data.get("win_lines").unwrap(), "1");
    assert_eq!(result.result_data.get("win_cells").unwrap(), "0,3,6");
}

#[test]
fn calculate_result_rejects_an_unfinished_state() {
    let game = SlotsGame::new();
    let state = game.prepare_state("alice", 10);

    assert!(game.calculate_result(&state).is_err());
}