use crate::protocol::{Item, PacketC, PacketS, ID};
use anyhow::{anyhow, Result};
use glam::UVec2;
use std::collections::{HashMap, VecDeque};

struct ItemData {}

struct TileData {
    items: Vec<ID>,
    active: bool,
}

struct Player {
    name: String,
    hand: Option<ID>,
}

#[derive(Default)]
pub struct Game {
    item_id_counter: ID,
    tiles: HashMap<UVec2, TileData>,
    items: HashMap<ID, Item>,
    players: HashMap<ID, Player>,
    packet_out: VecDeque<PacketC>,
}

impl Game {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn packet_out(&mut self) -> Option<PacketC> {
        self.packet_out.pop_front()
    }

    pub fn packet_in(&mut self, player: ID, packet: PacketS) -> Result<()> {
        match packet {
            PacketS::Join { name } => {
                self.players.insert(
                    player,
                    Player {
                        hand: None,
                        name: name.clone(),
                    },
                );
                self.packet_out
                    .push_back(PacketC::AddPlayer { id: player, name });
            }
            PacketS::Leave => {
                let p = self
                    .players
                    .remove(&player)
                    .ok_or(anyhow!("player does not exist"))?;
                if let Some(_i) = p.hand {
                    // TODO what now?
                }
                self.packet_out
                    .push_back(PacketC::RemovePlayer { id: player })
            }
            PacketS::Position { pos, rot } => {
                self.packet_out
                    .push_back(PacketC::Position { player, pos, rot });
            }
            PacketS::Interact { pos } => {
                let tile = self
                    .tiles
                    .get_mut(&pos)
                    .ok_or(anyhow!("interacting with empty tile"))?;
                let player_data = self
                    .players
                    .get_mut(&player)
                    .ok_or(anyhow!("player does not exist"))?;

                if let Some(item) = player_data.hand.take() {
                    tile.items.push(item);
                    self.packet_out.push_back(PacketC::PutItem { item, pos })
                } else {
                    if let Some(item) = tile.items.pop() {
                        player_data.hand = Some(item);
                        self.packet_out
                            .push_back(PacketC::TakeItem { item, player })
                    }
                }
            }
        }
        Ok(())
    }
}