use std::default::Default;

mod bgm {
    use std::fmt;
    use std::default::Default;
    use std::fmt::Display;

    use image::{Rgb, RgbImage};
    use imageproc::drawing::draw_text_mut;
    use rusttype::{FontCollection, Scale};

    #[derive(Debug,Clone,Copy,Eq,PartialEq)]
    pub enum Color {
        Black = 0,
        White = 1,
    }
    
    #[derive(Debug,Clone,Copy)]
    pub enum Phase {
        PickSides,
        Turn(Color),
    }
    
    #[derive(Debug,Clone,Default)]
    pub struct Player {
        pub born_off: u32,
        pub on_bar: u32,
    }
    
    #[derive(Debug,Clone,Copy)]
    pub enum Bin {
        Free,
        Black(u32),
        White(u32),
    }
    
    #[derive(Debug)]
    pub struct Game {
        pub phase : Phase,
        pub multiplier : u32,
        pub roll : [u8; 2],
        pub players : [Player; 2],
        pub bins : [Bin; 24],
    }
    
    impl Default for Game {
        fn default() -> Self {
            Game {
                phase: Phase::PickSides,
                multiplier: 1,
                roll: [0; 2],
                players: [
                    Player::default(),
                    Player::default(),
                ],
                bins: [Bin::Free; 24],
            }
        }
    }
    
    impl Display for Game {
        fn fmt(&self, f : &mut fmt::Formatter<'_>) -> fmt::Result {
            /*

            const BLACK_DIGITS : [char; 20] = [
                '❶', '❷', '❸', '❹', '❺', '❻', '❼', '❽', '❾', '❿',
                '⓫', '⓬', '⓭', '⓮', '⓯', '⓰', '⓱', '⓲', '⓳', '⓴',
            ];

            const WHITE_DIGITS : [char; 20] = [
                '➀', '➁', '➂', '➃', '➄', '➅', '➆', '➇', '➈', '➉',
                '⑪', '⑫', '⑬', '⑭', '⑮', '⑯', '⑰', '⑱', '⑲', '⑳',
            ];

            write!(f, "13 14 15 16 17 18 19 20 21 22 23 24\n")?;
            for b in &self.bins[12..=23] {
                match *b {
                    Bin::Free => write!(f, "-- ")?,
                    Bin::Black(n) => {
                        if n > 0 && n <= BLACK_DIGITS.len() as u32 {
                            write!(f, "{}  ", BLACK_DIGITS[(n-1) as usize])?;
                        } else {
                            write!(f, "{} ", n)?;
                        }
                    }
                    Bin::White(n) => {
                        if n > 0 && n <= WHITE_DIGITS.len() as u32 {
                            write!(f, "{}  ", WHITE_DIGITS[(n-1) as usize])?;
                        } else {
                            write!(f, "{} ", n)?;
                        }
                    }
                }
                
            }
            write!(f, "\n")?;
            
            for b in (&self.bins[0..=11]).iter().rev() {
                match *b {
                    Bin::Free => write!(f, "-- ")?,
                    Bin::Black(n) => {
                        if n > 0 && n <= BLACK_DIGITS.len() as u32 {
                            write!(f, "{}  ", BLACK_DIGITS[(n-1) as usize])?;
                        } else {
                            write!(f, "{} ", n)?;
                        }
                    }
                    Bin::White(n) => {
                        if n > 0 && n <= WHITE_DIGITS.len() as u32 {
                            write!(f, "{}  ", WHITE_DIGITS[(n-1) as usize])?;
                        } else {
                            write!(f, "{} ", n)?;
                        }
                    }
                }
            }
            
            write!(f, "\n")?;            
            write!(f, "12 11 10  9  8  7  6  5  4  3  2  1\n")?;

            */

            //*
            write!(f, "  ")?;
            for n in (13..=24).rev() { write!(f, "{:2}. ", n)?; }
            write!(f, "\n╭ ")?;

            for b in &self.bins[12..=23] {
                match *b {
                    Bin::Free => write!(f, "┈┈┈ ")?,
                    Bin::Black(n) => write!(f, "{:2}█ ", n)?,
                    Bin::White(n) => write!(f, "{:2}░ ", n)?
                }
            }
            write!(f, "╴\n╰ ")?;

            for b in (&self.bins[0..=11]).iter().rev() {
                match *b {
                    Bin::Free => write!(f, "┈┈┈ ")?,
                    Bin::Black(n) => write!(f, "{:2}█ ", n)?,
                    Bin::White(n) => write!(f, "{:2}░ ", n)?
                }
            }

            write!(f, "╴\n  ")?;
            for n in (1..=12).rev() { write!(f, "{:2}. ", n)?; }
            write!(f, "\n")?;
            //*/

            /*
            const DIGITS : &[u8; 36] = b"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

            write!(f, "   14  16  18  20  22  24\n")?;
            write!(f, " 13╲╱15╲╱17╲╱19╲╱21╲╱23╲╱\n")?;
            write!(f, "╭")?;

            for b in &self.bins[12..=23] {
                match *b {
                    Bin::Free => write!(f, "──")?,
                    Bin::Black(n) => write!(f, "{}█", DIGITS[n as usize] as char)?,
                    Bin::White(n) => write!(f, "{}░", DIGITS[n as usize] as char)?
                }
            }
            write!(f, "─┘\n╰")?;

            for b in (&self.bins[0..=11]).iter().rev() {
                match *b {
                    Bin::Free => write!(f, "──")?,
                    Bin::Black(n) => write!(f, "{}█", DIGITS[n as usize] as char)?,
                    Bin::White(n) => write!(f, "{}░", DIGITS[n as usize] as char)?
                }
            }

            write!(f, "─┐\n")?;
            write!(f, " 12╱╲10╱╲8.╱╲6.╱╲4.╱╲2.╱╲\n")?;
            write!(f, "   11  9.  7.  5.  3.  1.\n")?;
            */

            Ok(())
        }
    }
}

fn main() {
    let mut board = bgm::Game::default();
    
    board.bins[4] = bgm::Bin::Black(5);
    board.bins[5] = bgm::Bin::Black(2);
    board.bins[6] = bgm::Bin::Black(7);    
    
    board.bins[14] = bgm::Bin::White(9);
    board.bins[15] = bgm::Bin::White(10);
    board.bins[16] = bgm::Bin::White(11);
    board.bins[2] = bgm::Bin::White(2);


    println!("{}", board);
}