use crate::card::card::*;
use crate::card::player::*;

#[allow(dead_code)]
pub struct Grid<const SIZE: usize> {
    pub field: [[Option<Card>; SIZE]; SIZE],
}

const NO_CARD: Option<Card> = None;
impl<const SIZE: usize> Default for Grid<SIZE> {
    fn default() -> Self {
        Self {
            field: [[NO_CARD; SIZE]; SIZE],
        }
    }
}

impl<const SIZE: usize> Grid<SIZE> {
    pub fn randomize(&mut self) {
        for y in 0..SIZE {
            for x in 0..SIZE {
                let mut card = Card::default();
                card.randomize();
                self.field[y][x] = Some(card);
            }
        }
    }
}

fn get_owner(some_card: Option<Card>) -> &'static str {
    match some_card {
        Some(card) => {
            match card.owner {
                PlayerId::NONE => "( )",
                PlayerId::PLAYER_1 => "(1)",
                PlayerId::PLAYER_2 => "(2)",
            }
        }
        None => {
            "( )"
        }
    }
}

fn get_values(some_card: Option<Card>) -> [u8; 4] {
    match some_card {
        Some(card) => {
            [card.n, card.e, card.s, card.w]
        },
        None => {
            [0; 4]
        }
    }
}

fn get_value_u8(dir: usize, some_card: Option<Card>) -> u8 {
    let values = get_values(some_card);
    match dir {
        // P1N
        0 => {
            match some_card {
                Some(card) => {
                    match card.owner {
                        PlayerId::PLAYER_2 => values[2],
                        _ => values[0],
                    }
                }
                None => {0},
            }
        },
        // P1E
        1 => {
            match some_card {
                Some(card) => {
                    match card.owner {
                        PlayerId::PLAYER_2 => values[3],
                        _ => values[1],
                    }
                }
                None => {0},
            }
        },
        // P1S
        2 => {
            match some_card {
                Some(card) => {
                    match card.owner {
                        PlayerId::PLAYER_2 => values[0],
                        _ => values[2],
                    }
                }
                None => {0},
            }
        },
        // P1W
        3 => {
            match some_card {
                Some(card) => {
                    match card.owner {
                        PlayerId::PLAYER_2 => values[1],
                        _ => values[3],
                    }
                }
                None => {0},
            }
        },
        _ => {0},
    }
}

fn get_value(dir: usize, some_card: Option<Card>) -> String {
    let value = get_value_u8(dir, some_card);
    if value == 0 {
        return "   ".to_string();
    }
    return format!("{:<3?}", value);
}

impl<const SIZE: usize> core::fmt::Debug for Grid<SIZE> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if let Err(error) = write!(f, ".") {
            return Err(error);
        }
        for _x in 0..SIZE {
            if let Err(error) = write!(f, "============") {
                return Err(error);
            }
        }
        if let Err(error) = write!(f, ".\n") {
            return Err(error);
        }
        for y in (0..SIZE).rev() {
            for s in 0..3 {
                if let Err(error) = write!(f, "|") {
                    return Err(error);
                }
                for x in 0..SIZE {
                    match s {
                        0 => {
                            if let Err(error) = write!(f, "    {}     ", get_value(0, self.field[y][x])) {
                                return Err(error);
                            }
                        },
                        1 => {
                            if let Err(error) = write!(f, "{} {} {} ", get_value(3, self.field[y][x]), get_owner(self.field[y][x]), get_value(1, self.field[y][x])) {
                                return Err(error);
                            }
                        },
                        2 => {
                            if let Err(error) = write!(f, "    {}     ", get_value(2, self.field[y][x])) {
                                return Err(error);
                            }
                        },
                        _ => {},
                    };
                    //buf = match self.field[y][x] {
                    //    None => {write!(f, "{:?} ", PlayerId::NONE)},
                    //    Some(card) => {write!(f, "{:?} ", card.owner)},
                    //};
                }
                if let Err(error) = write!(f, "|\n") {
                    return Err(error);
                }
            }
        }
        if let Err(error) = write!(f, "'") {
            return Err(error);
        }
        for _x in 0..SIZE {
            if let Err(error) = write!(f, "============") {
                return Err(error);
            }
        }
        if let Err(error) = write!(f, "'\n") {
            return Err(error);
        }
        return Ok(())
    }
}