use rand::prelude::IteratorRandom;
use rand::thread_rng;
use serde::{Deserialize, Serialize};
use serde_json::Result;
use std::fs;

#[derive(Serialize, Deserialize)]
struct CAHCardWhite {
    text: String,
    pack: u8,
}

#[derive(Serialize, Deserialize)]
struct CAHCardBlack {
    text: String,
    pick: u8,
    pack: u8,
}

#[derive(Serialize, Deserialize)]
struct CAHCardSet {
    name: String,
    description: Option<String>,
    official: bool,
    white: Option<Vec<CAHCardWhite>>,
    black: Option<Vec<CAHCardBlack>>,
}

#[derive(Default)]
struct CAHPlayer {
    // white: Vec<CAHCardWhite>,
    // black: Vec<CAHCardBlack>,
}

#[derive(Default)]
struct CAHGame {
    white: Vec<CAHCardWhite>,
    black: Vec<CAHCardBlack>,
    // white_discard: Vec<CAHCardWhite>,
    // black_discard: Vec<CAHCardBlack>,
    // game_active: bool,
    players: Vec<CAHPlayer>,
    // czar: &CAHPlayer,
    // current_black: Option<CAHCardBlack>,
}

impl CAHGame {
    fn build_decks(&mut self, cards_json: Vec<CAHCardSet>) {
        for pack in cards_json {
            if let Some(white) = pack.white {
                self.white.extend(white)
            }
            if let Some(black) = pack.black {
                self.black.extend(black)
            }
        }
    }

    fn deck_counts(&self) {
        println!(
            "Deck Counts:\n {} White cards\n {} Black cards",
            self.white.len(),
            self.black.len()
        );
    }

    fn draw_one_white(&mut self) -> Result<CAHCardWhite> {
        let deck = &mut self.white;

        // this feels sloppy
        if let Some(index) = (0..deck.len()).choose(&mut thread_rng()) {
            Ok(deck.swap_remove(index))
        } else {
            Ok(CAHCardWhite {
                text: "Error.\n\nbtw if you see this tell me I'm lazy :)".to_string(),
                pack: 0,
            })
        }
    }

    fn draw_one_black(&mut self) -> Result<CAHCardBlack> {
        let deck = &mut self.black;

        // this feels sloppy
        if let Some(index) = (0..deck.len()).choose(&mut thread_rng()) {
            Ok(deck.swap_remove(index))
        } else {
            Ok(CAHCardBlack {
                text: "Error.\n\nbtw if you see this tell me I'm lazy :)".to_string(),
                pick: 0,
                pack: 0,
            })
        }
    }

    fn create_player(&mut self, player: CAHPlayer) {
        self.players.push(player);
        println!("Player Created!");
    }
}

fn load_json(path: &str) -> Result<Vec<CAHCardSet>> {
    let data: String = fs::read_to_string(path).expect("Error reading file");
    let jayson: Vec<CAHCardSet> = serde_json::from_str(&data)?;

    Ok(jayson)
}

fn main() -> Result<()> {
    // let cards_input_path: &str = "data/test.json";
    let cards_input_path: &str = "data/cah-cards-full.json";
    let cards_json: Vec<CAHCardSet> = load_json(cards_input_path)?;

    let mut cah_game = CAHGame {
        ..Default::default()
    };

    cah_game.build_decks(cards_json);
    cah_game.deck_counts();
    cah_game.create_player(CAHPlayer {
        ..Default::default()
    });

    // deal black
    let black_card = cah_game.draw_one_black()?;
    let div = "--------------------------";
    println!(
        "{}\nPick {}\n {}\n{}",
        div,
        black_card.pick.to_string(),
        black_card.text,
        div,
    );

    // deal white
    for i in 1..11 {
        let card = cah_game.draw_one_white()?;
        println!("{} {}", i, card.text);
    }

    cah_game.deck_counts();
    Ok(())
}