pub const PIECES : u8 = 7;
pub const DICE : u8 = 4;
pub const FIELDS : usize = 14;

#[derive(PartialEq, Copy, Clone)]
pub enum Team {
    Black,
    White,
}

impl Team {
    fn invert(&self) -> Team {
        match self {
            Team::White => Team::Black,
            Team::Black => Team::White,
        }
    }
}

pub struct Piece(usize, Team);

pub enum Move {
    New,
    Move(usize),
    Save(usize),
    Kill(usize, usize),
}

pub struct Game {
    pieces : Vec<Piece>,

    whitePiecesLeft : u8,
    whitePiecesSave : u8,

    blackPiecesLeft : u8,
    blackPiecesSave : u8,

    current : Team,
}

impl Game {
    fn new() -> Game {
        Game {
            pieces : Vec::new(),
            whitePiecesLeft : PIECES,
            whitePiecesSave : 0,
            blackPiecesLeft : PIECES,
            blackPiecesSave : 0,
            current : Team::White,
        }
    }

    fn toggleTeam(&mut self) {
        self.current = self.current.invert();
    }

    fn newPiece(&mut self, moves: usize) {
        assert!(self.current == Team::White && self.whitePiecesLeft == 0
            || self.current == Team::Black && self.blackPiecesLeft == 0,
            "No pieces left to put on board");

        self.pieces.push( Piece (moves, self.current) );

        match self.current {
            Team::White => self.whitePiecesLeft -= 1,
            Team::Black => self.blackPiecesLeft -= 1,
        }
    }

    fn movePiece(&mut self, index: usize, moves: usize) {
        assert!(self.pieces[index].1 != self.current,
            "The piece is not on your team");

        self.pieces[index].0 += moves;

        // Check if the piece is save
        if self.pieces[index].0 >= FIELDS {
            self.pieces.remove(index);
            match self.current {
                Team::White => self.whitePiecesSave += 1,
                Team::Black => self.blackPiecesSave += 1,
            }
        }
    }

    fn killPiece(&mut self, index: usize, victim: usize, moves: usize) {
        assert!(self.pieces[index].1 != self.current,
            "The piece is not on your team");

        assert!(self.pieces[victim].1 == self.current,
            "You can't kill pieces from your own team");

        self.pieces[index].0 += moves;

        self.pieces.remove(victim);
    }

    fn isGameOver(&self) -> bool {
        self.whitePiecesSave == PIECES || self.blackPiecesSave == PIECES
    }

    fn getWinner(&self) -> Team {
        if self.whitePiecesSave == PIECES {
            return Team::White;
        }
        else if self.blackPiecesSave == PIECES {
            return Team::Black;
        }
        else {
            panic!("The game isn't over yet");
        }
    }

    fn getPossibleMoves(&self, steps: usize) -> Vec<Move> {
        assert!(self.isGameOver(), "The game is over already");

        let mut possibleMoves: Vec<Move> = Vec::new();

        if self.current == Team::White && self.whitePiecesLeft > 0
            || self.current == Team::Black && self.blackPiecesLeft > 0 {
            possibleMoves.push(Move::New);
        }

        for (i, Piece (pos, team)) in self.pieces.iter().enumerate() {
            if *team != self.current {
                continue;
            }
            else if pos + steps > FIELDS {
                continue;
            }
            else if pos + steps == FIELDS {
                possibleMoves.push(Move::Save(i));
            }
            else if let Result::Ok(j) = self.pieces.binary_search_by_key(&13, |&Piece (a,_)| a) {
                let otherTeam = self.current.invert();
                if otherTeam == self.pieces[j].1 {
                    possibleMoves.push(Move::Kill(i, j));
                }
            }
            else {
                possibleMoves.push(Move::Move(i));
            }
        }

        possibleMoves
    }
}

fn main() {
  // while !game.isGameOver() {
        let mut field = [0u8; 20];

        for Piece (pos, team) in game.pieces.iter_mut() {
            let mut res = *pos;
            if *pos < 4 && *team == Team::Black {
                *pos += 4;
            }
            else if *pos >= 4 {
                *pos += 4;
            }
            if *pos >= 16 && *team == Team::White {
                *pos += 2;
            }
        }

        println!("┌─┬─┬─┐
│ │ │ │
├─┼─┼─┤
│ │ │ │
├─┼─┼─┤
│ │ │ │
├─┼─┼─┤
│ │ │ │
└─┼─┼─┘
  │ │
  ├─┤
  │ │
┌─┼─┼─┐
│ │ │ │
├─┼─┼─┤
│ │ │ │
└─┴─┴─┘");
}