// #[allow(dead_code, unused)]

// vigyazz6! autplayer

//

use core::{fmt, panic};

use rand::Rng;

use std::mem;

extern crate pretty_env_logger;

#[macro_use] extern crate log;

const GAME_ROUNDS: i32 = 1_000_000;

fn main() {

    // RUST_LOG=debug cargo run

    pretty_env_logger::init();

    info!("Program starting.");

    game();

    info!("End of run.");

}

/*** Card ****/

#[derive(Debug)]

struct Card {

    value: i8,

    points: i8,

}

impl Card {

    fn new(value: i8)->Self {

        let mut points = 0;

        if value % 10 == 5 {

            // ends with 5 = 2 point

            points = 2;

            // println!("*5 add 1, val={}, pt={}", value, points);

        }

        if value % 10 == 0 {

            // ends with 0 = 3 point

            points = 3;

            // println!("*0 add 2, val={}, pt={}", value, points);

        }

        if value % 10 == value / 10 {

            // same numbers = 5 points (55=7)

            points += 5;

            // println!("NN add 5, val={}, pt={}", value, points);

        }

        if points == 0 {

            points = 1;

        }

        Card {

            value,

            points,

        }

    }

}

impl fmt::Display for Card {

    fn fmt( &self, f: &mut fmt::Formatter ) -> fmt::Result {

        write!(f, "(Card {}, points {})", self.value, self.points)

    }

}

impl PartialEq for Card {

    fn eq(&self, other: &Self) -> bool {

        self.value == other.value

    }

}

impl Eq for Card {} 

impl PartialOrd for Card {

    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {

        match self.value.partial_cmp(&other.value) {

            Some(core::cmp::Ordering::Equal) => {None}

            ord => return ord,

        }

    }

}

impl Ord for Card {

    fn cmp(&self, other: &Self) -> std::cmp::Ordering {

        self.value.cmp(&other.value)

    }

}

/*** Deck ****/

#[derive(Debug)]

struct Deck {

    content: VecDeque<Card>,

}

impl Deck {

    fn new_empty() -> Self {

        debug!("Empty deck generated");

        Deck {

            content: VecDeque::new(),

        }

    }

    fn new() -> Self {

        debug!("Full deck generated");

        let content = (1..=104).into_iter().map( |n| Card::new(n) ).collect();

        Deck {

            content,

        }

    }

    fn shuffle( &mut self ) {

        let mut rng = rand::thread_rng();

        trace!("Deck before shuffle: len {}, {:?}", self.content.len(), self);

        debug!("Deck shuffled");

        // shufflers:

        // * naive: swap cards n times

        // * kgb: half the deck, take 1..4 cards sequentially from each

        // * grin: take 1..6 from front and put at bottom

        // naive shuffle: exchange random cards

        for _i in 1..=500 {

            let c1 = rng.gen_range(0 .. self.content.len());

            let c2 = rng.gen_range(0 .. self.content.len());

            if c1 != c2 {

                self.content.swap(c1, c2);

            }

        }

        trace!("Deck after shuffle: len {}, {:?}", self.content.len(), self);

    }

    // get top card from deck

    fn pop( &mut self ) -> Option<Card> {

        self.content.pop_front() 

    }

    // put a card into the bottom of the deck

    fn push( &mut self, c: Card ) {

        self.content.push_back(c);

    }

    fn push_cards( &mut self, cards: VecDeque<Card> ) {

        trace!("Collecting back, deck len is {}, cards {}", self.content.len(), cards.len());

        cards.into_iter().for_each( |card| self.push(card) );

        trace!("Deck len is {}", self.content.len());

    }

    fn len( &self ) -> usize {

        self.content.len()

    }

        if let Some(c) = self.content.remove(n) {

            c

        } else {

            panic!("get_nth: index {} out of bounds ({})!", n, self.content.len());

        }

    }

}

/*** Player ****/

#[derive(Debug)]

struct Player {

    name: String,

    hand: Deck,

    pile: VecDeque<Card>,

    game_point: i32,

    total_point: i32,

    rows_busted: i32,

    wins: i32,

}

impl Player {

    fn new(name: String)->Self {

        debug!("Player {} created", name);

        Player {

            name,

            hand: Deck::new_empty(),

            pile: VecDeque::new(),

            game_point: 0,

            total_point: 0,

            rows_busted: 0,

            wins: 0,

        }

    }

    // get one card from th dealer

    fn get_card( &mut self, card: Card ) {

        trace!("Player {} got a card {:?}, cards before {}", self.name, &card, self.hand.len());

        self.hand.push(card);

    }

    // throw a card from hand to the table

    fn throw_card( &mut self )->Card {

        if let Some(c) = self.hand.pop() {

            trace!("Player {} throws a card {:?}", self.name, &c);

            c

        } else {

            panic!("throw_card: Player {} has no card in hand!", self.name);

        }

    }

    // get a busted row of cards

    fn give_pile( &mut self, cards: VecDeque<Card> ) {

        for c in cards.into_iter() {

            self.game_point += c.points as i32;

            self.pile.push_back(c);

        }

        self.rows_busted += 1;

        trace!("Player {} got busted, count {}", self.name, &self.rows_busted);

    }

    // ask the player their score

        self.game_point

    }

    fn inc_wins( &mut self ) {

        self.wins += 1;

    }

    // give back cards from the pile

    fn get_pile( &mut self ) -> VecDeque<Card> {

        trace!("Player {} gives back their pile", self.name);

        mem::take( &mut self.pile )

        // same effect:

        // self.pile.drain(..).collect()

        // very cumbersome manual fiddling (also reverted...)

/*         let mut throw: Vec<Card> = Vec::new();

        for _i in 0 .. self.pile.len() {

            throw.push( self.pile.pop().unwrap() );

        }

        throw

 */    

    }

    // I can do this just because I *throw away* c!

    // doesn't work if I want to use it.

/*     fn _gimme_pile(self)->Self {

        for c in &self.pile {

            println!("Throw {} ", c);

        }

        self

    }

 */

    fn close_round( &mut self ) {

        if self.hand.len() > 0 {

            panic!("Closing round when {} has {} cards in hand", self.name, self.hand.len());

        }

        if self.pile.len() > 0 {

            panic!("Closing round when {} stil have pile with {} cards", self.name, self.pile.len());

        }

        trace!("Player {} closing round; points={} total so far {}", self.name, self.game_point, self.total_point);

        self.total_point += self.game_point;

        self.game_point = 0;

    }

    // card too small: pick a row to collect from the rows

    fn pick_row_for_small_card( &self, rows: &Vec<Row>, playercard: &Card ) -> usize {

        trace!("Player {} picking a row for small card, card {:?}, rows {:?}", self.name, playercard, rows);

        // contains the summary point for each row

        // the smallest row score

        let mut smallest = 999;

        // how many rows have the same smallest score

        let mut same_point = 0;

        // the first smallest row_id

        let mut smallest_rowid = 255;

        for rowid in 0 .. rows.len() {

            // DEBUG

            // println!("pick_row_for_small_card: rowlen {}, rowid {}", rows.len(), rowid);

            row_points.push( rows[rowid].sum() );

            if row_points[rowid] < smallest {

                // we have a new smallest row

                smallest = row_points[rowid];

                same_point = 0;

                smallest_rowid = rowid;

            } else if row_points[rowid] == smallest {

                // we have another row with same point as smallest

                same_point += 1;

            }

        }

        if same_point < 1 {

            // we have one smallest row

            smallest_rowid.try_into().unwrap()      // it's tiny, will fit into u8

        } else {

            // bored, we pick the first now anyway

            smallest_rowid.try_into().unwrap()

        }

    }

}

/*** Row ****/

// a row of cards on the table (max 5)

#[derive(Debug)]

struct Row {

    cards: VecDeque<Card>,

}

impl Row {

    const MAX_LEN: usize = 5;

    fn new() -> Self {

        Row {

        }

    }

    fn push_or_collect( &mut self, card: Card ) -> Option<VecDeque<Card>> {

        trace!("Called push_or_collect on row {:?}", &self);

        if self.cards.len() < Self::MAX_LEN {

            trace!("Less than {} cards, putting at the end", Self::MAX_LEN);

            self.cards.push_back(card);

            None

        } else {

            trace!("Row is full, len {}, maxlen {}", self.cards.len(), Self::MAX_LEN);

            // row overflow

            let row_cards = mem::take( &mut self.cards );

            self.cards.push_back(card);

            if self.cards.len() != 1 {

                panic!("New row must have one card, not {}", self.cards.len());

            }

            Some(row_cards)

        }

    }

    fn take_row( &mut self ) -> VecDeque<Card> {

        // take cards and empty the row

        mem::take( &mut self.cards )

    }

    fn last_card_value(&self) -> i8 {

        // println!("last_card_value: cards {:?}, len {}", self.cards, self.cards.len());

        self.cards.get( self.cards.len()-1 ).unwrap().value

    }

    // sum of row card points

    fn sum(&self) -> i32 {

        let mut sum: i32 = 0;

        self.cards.iter().for_each(|card| {

            sum += card.points as i32;

        });

        sum

    }

}

/*** PlayerCard ****/

#[derive(Debug)]

struct PlayerCard {

    player_id: i32,

    card: Card,

}

impl PlayerCard {

        self.player_id

    }

}