use rand::Rng;

fn rand_u8() -> u8 {
    let mut rng = rand::thread_rng();
    rng.gen()
}

#[allow(dead_code)]
#[derive(Copy,Clone)]
struct CardEffect {
    name: &'static str,
    when: usize, // TODO: Change this
    fun: &'static dyn Fn(),
}

impl core::fmt::Debug for CardEffect {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "{}", self.name)
    }
}

#[allow(dead_code)]
#[derive(Copy,Clone)]
struct Card {
    n: u8,
    e: u8,
    s: u8,
    w: u8,
    owner: PlayerId,
    effect: Option<CardEffect>,
}

#[allow(non_camel_case_types)]
#[allow(dead_code)]
#[derive(Copy,Clone)]
enum PlayerId {
    NONE,
    PLAYER_1,
    PLAYER_2,
}

impl Default for PlayerId {
    fn default() -> Self {
        PlayerId::NONE
    }
}

impl core::fmt::Debug for PlayerId {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match *self {
            PlayerId::NONE => {
                write!(f, "PlayerId::NONE    ")
            },
            PlayerId::PLAYER_1 => {
                write!(f, "PlayerId::PLAYER_1")
            },
            PlayerId::PLAYER_2 => {
                write!(f, "PlayerId::PLAYER_2")
            },
        }
    }
}

#[allow(dead_code)]
impl Default for Card {
    fn default() -> Self {
        Card {
            n: 0,
            e: 0,
            s: 0,
            w: 0,
            owner: PlayerId::default(),
            effect: None,
        }
    }
}

impl core::fmt::Debug for Card {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        if let Err(error) = write!(f, "Card {{\n\towner: {:?}\n\tn: {:?},\n\te: {:?},\n\ts: {:?},\n\tw: {:?}", self.owner, self.n, self.e, self.s, self.w) {
            return Err(error);
        }
        if let Some(effect) = self.effect {
            if let Err(error) = write!(f, "\n\teffect: {:?}", effect) {
                return Err(error);
            }
        }
        write!(f, "\n}}")
    }
}

impl Card {
    fn new(owner: PlayerId) -> Self {
        Self {
            n: 0,
            e: 0,
            s: 0,
            w: 0,
            owner: owner,
            effect: None,
        }
    }

    fn randomize(&mut self) {
        self.n = rand_u8();
        self.e = rand_u8();
        self.s = rand_u8();
        self.w = rand_u8();
    }
}

#[allow(dead_code)]
struct Grid<const SIZE: usize> {
    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> {
    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(())
    }
}

fn special_000() {
    println!("Hello, world!");
}

#[allow(unused_variables)]
fn main() {
    let mut card = Card::new(PlayerId::PLAYER_1);
    println!("{:?}", card);
    card.n ^= 5;
    println!("{:?}", card);
    card.n ^= 3;
    println!("{:?}", card);
    card.n = 254;
    card.effect = Some(CardEffect {
        name: "Say Hello",
        when: 0,
        fun: &special_000,
    });
    println!("{:?}", card);
    card.randomize();
    println!("{:?}", card);
    if let Some(effect) = card.effect {
        (effect.fun)();
    }
    let mut grid = Grid::<3>::default();
    println!("{:?}", grid);
    grid.field[0][1] = Some(card);
    println!("{:?}", grid);
    grid.randomize();
    println!("{:?}", grid);
}