use rand::Rng;
use std::fmt;

#[derive(Clone, Copy, Eq, PartialEq)]
pub enum CardSuit {
    Diamonds,
    Clubs,
    Hearts,
    Spades,
}

#[derive(Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord, Hash)]
pub enum CardValue {
    Two = 2,
    Three,
    Four,
    Five,
    Six,
    Seven,
    Eight,
    Nine,
    Ten,
    Jack,
    Queen,
    King,
    Ace,
}

#[derive(PartialEq, Eq, Clone, Copy)]
pub struct PlayingCard {
    pub value: CardValue,
    pub suit: CardSuit,
}

impl Ord for PlayingCard {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        self.value.cmp(&other.value)
    }
}

impl PartialOrd for PlayingCard {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.value.partial_cmp(&other.value)
    }
}

impl fmt::Display for PlayingCard {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let suit = match self.suit {
            CardSuit::Clubs => "♣",
            CardSuit::Diamonds => "♦",
            CardSuit::Hearts => "♥",
            CardSuit::Spades => "♠",
        };

        write!(f, "{:?}{}", self.value, suit)
    }
}

pub fn draw_card(deck: &mut Vec<PlayingCard>) -> PlayingCard {
    let num = rand::thread_rng().gen_range(0..deck.len());
    let card = deck.remove(num);

    card
}

pub fn create_deck() -> Vec<PlayingCard> {
    let mut deck: Vec<PlayingCard> = vec![];
    let suits = [
        CardSuit::Diamonds,
        CardSuit::Clubs,
        CardSuit::Hearts,
        CardSuit::Spades,
    ];

    let values = [
        CardValue::Two,
        CardValue::Three,
        CardValue::Four,
        CardValue::Five,
        CardValue::Six,
        CardValue::Seven,
        CardValue::Eight,
        CardValue::Nine,
        CardValue::Ten,
        CardValue::Jack,
        CardValue::Queen,
        CardValue::King,
        CardValue::Ace,
    ];

    for s in suits {
        for i in values {
            let card = PlayingCard { suit: s, value: i };
            deck.insert(0, card);
        }
    }

    deck
}