use crate::core::logic::*;
use crate::core::enums::*;

const TEST_CARDS: &str = r#"{
    "member_db": {
        "0": {
            "card_id": 0,
            "card_no": "TEST-001",
            "name": "Test Member",
            "cost": 2,
            "hearts": [1, 0, 0, 0, 0, 0, 0],
            "blade_hearts": [0, 0, 0, 0, 0, 0, 0],
            "blades": 1,
            "groups": [],
            "units": [],
            "abilities": [],
            "rare": "R",
            "volume_icons": 0,
            "draw_icons": 0
        }
    },
    "live_db": {
        "11000": {
            "card_id": 11000,
            "card_no": "LIVE-001",
            "name": "Test Live",
            "score": 1,
            "required_hearts": [1, 0, 0, 0, 0, 0, 0],
            "abilities": [],
            "groups": [],
            "units": [],
            "volume_icons": 0,
            "blade_hearts": [0, 0, 0, 0, 0, 0, 0]
        }
    }
}"#;

#[test]
fn test_database_load() {
    let db = CardDatabase::from_json(TEST_CARDS).unwrap();
    assert_eq!(db.members.len(), 1);
    assert_eq!(db.lives.len(), 1);
    assert_eq!(db.members[&0].name, "Test Member");
}

#[test]
fn test_game_initialization() {
    let db = CardDatabase::from_json(TEST_CARDS).unwrap();
    let mut state = GameState {
        players: [
            PlayerState {
                player_id: 0,
                ..PlayerState::default()
            },
            PlayerState {
                player_id: 1,
                ..PlayerState::default()
            },
        ],
        ..GameState::default()
    };

    state.initialize_game(
        vec![0; 10], // P0 Deck
        vec![0; 10], // P1 Deck
        vec![0; 5],  // P0 Energy
        vec![0; 5],  // P1 Energy
        vec![11000],   // P0 Lives
        vec![11000],   // P1 Lives
    );

    assert_eq!(state.players[0].hand.len(), 6);
    assert_eq!(state.players[0].energy_zone.len(), 3); // Based on logic.rs (3 energy)
    // Lives are mixed into deck in current implementation, not placed in live_zone
    // assert_eq!(state.players[0].live_zone[0], 11000);
    assert!(state.players[0].deck.contains(&11000) || state.players[0].hand.contains(&11000));
}

#[test]
fn test_play_member() {
    let db = CardDatabase::from_json(TEST_CARDS).unwrap();
    let mut state = GameState {
        players: [
            PlayerState {
                player_id: 0,
                hand: vec![0],
                energy_zone: vec![0, 0],
                tapped_energy: vec![false, false],
                ..PlayerState::default()
            },
            PlayerState {
                player_id: 1,
                ..PlayerState::default()
            },
        ],
        phase: Phase::Main,
        ..GameState::default()
    };

    // Play card 0 (cost 2) to slot 0
    state.play_member(&db, 0, 0).unwrap();

    assert_eq!(state.players[0].stage[0], 0);
    assert_eq!(state.players[0].hand.len(), 0);
    assert_eq!(state.players[0].tapped_energy.iter().filter(|&&t| t).count(), 2);
}

#[test]
fn test_performance_phase() {
    let db = CardDatabase::from_json(TEST_CARDS).unwrap();
    let mut state = GameState {
        players: [
            PlayerState {
                player_id: 0,
                deck: vec![0], // Deck for yelling
                live_zone: [11000, -1, -1],
                stage: [0, -1, -1],
                ..PlayerState::default()
            },
            PlayerState {
                player_id: 1,
                ..PlayerState::default()
            },
        ],
        phase: Phase::PerformanceP1,
        ..GameState::default()
    };

    state.do_performance_phase(&db);

    // After performance, if successful, the live should remain in live_zone
    // It is moved to success_lives only in LiveResult phase
    assert_eq!(state.players[0].live_zone[0], 11000);
    assert_eq!(state.players[0].current_turn_volume, 0); // Icons: 0
}