use std::cmp::Ordering;
use thiserror::Error;
use libpso::character::character;
use crate::entity::character::CharacterEntityId;
use crate::entity::item::{ItemEntityId, ItemDetail, ItemEntity, ItemType, InventoryEntity, InventoryItemEntity, EquippedEntity};
use crate::entity::item::tool::{Tool, ToolType};
use crate::entity::item::mag::Mag;
use crate::entity::item::weapon::Weapon;
use crate::ship::items::{ClientItemId, BankItem, BankItemHandle, ItemManagerError};
use crate::ship::items::floor::{IndividualFloorItem, StackedFloorItem};
use crate::ship::shops::{ShopItem, ArmorShopItem, ToolShopItem, WeaponShopItem};

const INVENTORY_CAPACITY: usize = 30;


#[derive(Debug, Clone)]
pub struct InventorySlot(pub usize);


#[derive(Debug, Clone)]
pub struct IndividualInventoryItem {
    pub entity_id: ItemEntityId,
    pub item_id: ClientItemId,
    pub item: ItemDetail,
}

impl IndividualInventoryItem {
    pub fn mag(&self) -> Option<&Mag> {
        match self.item {
            ItemDetail::Mag(ref mag) => Some(mag),
            _ => None
        }
    }

    pub fn weapon(&self) -> Option<&Weapon> {
        match self.item {
            ItemDetail::Weapon(ref weapon) => Some(weapon),
            _ => None
        }
    }

    pub fn mag_mut(&mut self) -> Option<&mut Mag> {
        match self.item {
            ItemDetail::Mag(ref mut mag) => Some(mag),
            _ => None
        }
    }
}

#[derive(Debug, Clone)]
pub struct StackedInventoryItem {
    pub entity_ids: Vec<ItemEntityId>,
    pub item_id: ClientItemId,
    pub tool: Tool,
}

impl StackedInventoryItem {
    pub fn count(&self) -> usize {
        self.entity_ids.len()
    }

    pub fn take_entity_ids(&mut self, amount: usize) -> Option<Vec<ItemEntityId>> {
        if amount <= self.count() {
            Some(self.entity_ids.drain(..amount).collect())
        }
        else {
            None
        }
    }
}

#[derive(Debug, Clone)]
pub enum InventoryItem {
    Individual(IndividualInventoryItem),
    Stacked(StackedInventoryItem),
}

#[derive(Error, Debug, Clone)]
#[error("")]
pub enum InventoryItemAddToError {
    BothAreNotStacked,
    DifferentTool,
    ExceedsCapacity,
}

#[derive(Error, Debug, Clone)]
#[error("")]
pub enum InventoryAddError {
}

#[derive(Debug, Clone)]
pub enum YesThereIsSpace {
    NewStack,
    ExistingStack,
}

#[derive(Debug, Clone)]
pub enum NoThereIsNotSpace {
    FullStack,
    FullInventory,
}

#[derive(Debug, Clone)]
pub enum SpaceForStack {
    Yes(YesThereIsSpace),
    No(NoThereIsNotSpace),
}

impl InventoryItem {
    pub fn entity_ids(&self) -> Vec<ItemEntityId> {
        match self {
            InventoryItem::Individual(individual_inventory_item) => {
                vec![individual_inventory_item.entity_id]
            },
            InventoryItem::Stacked(stacked_inventory_item) => {
                stacked_inventory_item.entity_ids.clone()
            }
        }
    }

    pub fn item_id(&self) -> ClientItemId {
        match self {
            InventoryItem::Individual(individual_inventory_item) => {
                individual_inventory_item.item_id
            },
            InventoryItem::Stacked(stacked_inventory_item) => {
                stacked_inventory_item.item_id
            }
        }
    }

    pub fn set_item_id(&mut self, item_id: ClientItemId) {
        match self {
            InventoryItem::Individual(individual_inventory_item) => {
                individual_inventory_item.item_id = item_id
            },
            InventoryItem::Stacked(stacked_inventory_item) => {
                stacked_inventory_item.item_id = item_id
            }
        }
    }

    pub fn item_type(&self) -> ItemType {
        match self {
            InventoryItem::Individual(individual_inventory_item) => {
                individual_inventory_item.item.item_type()
            },
            InventoryItem::Stacked(stacked_inventory_item) => {
                ItemType::Tool(stacked_inventory_item.tool.tool)
            }
        }
    }

    // TOOD: delete?
    pub fn are_same_stackable_tool(&self, other_stacked_item: &StackedFloorItem) -> bool {
        match self {
            InventoryItem::Stacked(self_stacked_item) => {
                self_stacked_item.tool == other_stacked_item.tool
                    && self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
            },
            _ => false
        }
    }

    // TOOD: delete?
    pub fn can_combine_stacks(&self, other_stacked_item: &StackedFloorItem) -> bool {
        match self {
            InventoryItem::Stacked(self_stacked_item) => {
                self_stacked_item.tool == other_stacked_item.tool
                    && self_stacked_item.tool.is_stackable() && other_stacked_item.tool.is_stackable()
                    && self_stacked_item.count() + other_stacked_item.count() <= self_stacked_item.tool.max_stack()
            },
            _ => false
        }
    }

    // TODO: result
    // TOOD: delete?
    pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
        if let InventoryItem::Stacked(self_stacked_item) = self {
            self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
        }
    }

    pub fn as_client_bytes(&self) -> [u8; 16] {
        match self {
            InventoryItem::Individual(item) => {
                match &item.item {
                    ItemDetail::Weapon(w) => w.as_bytes(),
                    ItemDetail::Armor(a) => a.as_bytes(),
                    ItemDetail::Shield(s) => s.as_bytes(),
                    ItemDetail::Unit(u) => u.as_bytes(),
                    ItemDetail::Tool(t) => t.as_individual_bytes(),
                    ItemDetail::TechniqueDisk(d) => d.as_bytes(),
                    ItemDetail::Mag(m) => m.as_bytes(),
                    ItemDetail::ESWeapon(e) => e.as_bytes(),
                }
            },
            InventoryItem::Stacked(item) => {
                item.tool.as_stacked_bytes(item.entity_ids.len())
            },
        }
    }

    pub fn can_add_to(&mut self, stacked_floor_item: &StackedFloorItem) -> Result<(), InventoryItemAddToError> {
        if let InventoryItem::Stacked(stacked_inventory_item) = self {
            if stacked_floor_item.tool != stacked_inventory_item.tool {
                return Err(InventoryItemAddToError::DifferentTool)
            }

            if stacked_floor_item.tool.tool.max_stack() < (stacked_floor_item.count() + stacked_inventory_item.count()) {
                return Err(InventoryItemAddToError::ExceedsCapacity)
            }
            Ok(())
        }
        else {
            Err(InventoryItemAddToError::BothAreNotStacked)
        }
    }

    pub fn add_to(&mut self, mut stacked_floor_item: StackedFloorItem) -> Result<(), InventoryItemAddToError> {
        self.can_add_to(&stacked_floor_item)?;
        if let InventoryItem::Stacked(stacked_inventory_item) = self {
            stacked_inventory_item.entity_ids.append(&mut stacked_floor_item.entity_ids);
        }
        Ok(())
    }

    pub fn individual(&self) -> Option<&IndividualInventoryItem> {
        match self {
            InventoryItem::Individual(ref individual_inventory_item) => Some(individual_inventory_item),
            _ => None
        }
    }

    pub fn individual_mut(&mut self) -> Option<&mut IndividualInventoryItem> {
        match self {
            InventoryItem::Individual(ref mut individual_inventory_item) => Some(individual_inventory_item),
            _ => None
        }
    }

    pub fn get_sell_price(&self) -> Result<u32, ItemManagerError> {
        match self {
            InventoryItem::Individual(individual_item) => {
                match &individual_item.item {
                    // TODO: can wrapped items be sold?
                    ItemDetail::Weapon(w) => {
                        if !w.tekked {
                            return Ok(1u32)
                        }
                        if w.is_rare_item() {
                            return Ok(10u32)
                        }
                        Ok((WeaponShopItem::from(w).price() / 8) as u32)
                    },
                    ItemDetail::Armor(a) => {
                        if a.is_rare_item() {
                            return Ok(10u32)
                        }
                        Ok((ArmorShopItem::from(a).price() / 8) as u32)
                    },
                    ItemDetail::Shield(s) => {
                        if s.is_rare_item() {
                            return Ok(10u32)
                        }
                        Ok((ArmorShopItem::from(s).price() / 8) as u32)
                    },
                    ItemDetail::Unit(u) => {
                        if u.is_rare_item() {
                            return Ok(10u32)
                        }
                        Ok((ArmorShopItem::from(u).price() / 8) as u32)
                    },
                    ItemDetail::Tool(t) => {
                        if !matches!(t.tool, ToolType::PhotonDrop | ToolType::PhotonSphere | ToolType::PhotonCrystal) && t.is_rare_item() {
                            return Ok(10u32)
                        }
                        Ok((ToolShopItem::from(t).price() / 8) as u32)
                    },
                    ItemDetail::TechniqueDisk(d) => {
                        Ok((ToolShopItem::from(d).price() / 8) as u32)
                    },
                    ItemDetail::Mag(_m) => {
                        Err(ItemManagerError::ItemNotSellable(self.clone()))
                    },
                    ItemDetail::ESWeapon(_e) => {
                        Ok(10u32)
                    },
                }
            },
            // the number of stacked items sold is handled by the caller. this is just the price of 1
            InventoryItem::Stacked(stacked_item) => {
                Ok((ToolShopItem::from(&stacked_item.tool).price() / 8) as u32)
            },
        }
    }

    pub fn stacked(&self) -> Option<&StackedInventoryItem> {
        match self {
            InventoryItem::Stacked(ref stacked_inventory_item) => Some(stacked_inventory_item),
            _ => None
        }
    }

    pub fn stacked_mut(&mut self) -> Option<&mut StackedInventoryItem> {
        match self {
            InventoryItem::Stacked(ref mut stacked_inventory_item) => Some(stacked_inventory_item),
            _ => None
        }
    }

    pub fn mag(&self) -> Option<&Mag> {
        match self {
            InventoryItem::Individual(individual_inventory_item) => individual_inventory_item.mag(),
            _ => None
        }
    }
}




#[derive(Error, Debug, Clone)]
#[error("")]
pub enum InventoryItemConsumeError {
    InconsistentState,
    InvalidAmount,
}

pub struct IndividualConsumedItem {
    pub entity_id: ItemEntityId,
    pub item: ItemDetail,
}

pub struct StackedConsumedItem {
    pub entity_ids: Vec<ItemEntityId>,
    pub tool: Tool
}

pub enum ConsumedItem {
    Individual(IndividualConsumedItem),
    Stacked(StackedConsumedItem),
}

impl ConsumedItem {
    pub fn entity_ids(&self) -> Vec<ItemEntityId> {
        match self {
            ConsumedItem::Individual(individual_consumed_item) => {
                vec![individual_consumed_item.entity_id]
            },
            ConsumedItem::Stacked(stacked_consumed_item) => {
                stacked_consumed_item.entity_ids.clone()
            }
        }
    }

    pub fn item(&self) -> ItemDetail {
        match self {
            ConsumedItem::Individual(individual_consumed_item) => {
                individual_consumed_item.item.clone()
            },
            ConsumedItem::Stacked(stacked_consumed_item) => {
                ItemDetail::Tool(stacked_consumed_item.tool)
            }
        }
    }
}


pub struct InventoryItemHandle<'a> {
    inventory: &'a mut CharacterInventory,
    slot: usize,
}

impl<'a> InventoryItemHandle<'a> {
    pub fn item(&'a self) -> Option<&'a InventoryItem> {
        self.inventory.items.get(self.slot)
    }

    pub fn item_mut(&mut self) -> Option<&mut InventoryItem> {
        self.inventory.items.get_mut(self.slot)
    }

    pub fn remove_from_inventory(self) {
        self.inventory.items.remove(self.slot);
    }

    pub fn consume(self, amount: usize) -> Result<ConsumedItem, InventoryItemConsumeError> {
        enum RemoveMethod {
            EntireThing(ConsumedItem),
            Partial(Tool),
        }

        let inventory_item = self.inventory.items.get(self.slot).ok_or(InventoryItemConsumeError::InconsistentState)?;
        let remove_method = match inventory_item {
            InventoryItem::Individual(individual_inventory_item) => {
                RemoveMethod::EntireThing(ConsumedItem::Individual(IndividualConsumedItem {
                    entity_id: individual_inventory_item.entity_id,
                    item: individual_inventory_item.item.clone()
                }))
            },
            InventoryItem::Stacked(stacked_inventory_item) => {
                match stacked_inventory_item.count().cmp(&amount) {
                    Ordering::Equal => {
                        RemoveMethod::EntireThing(ConsumedItem::Stacked(StackedConsumedItem {
                            entity_ids: stacked_inventory_item.entity_ids.clone(),
                            tool: stacked_inventory_item.tool,
                        }))
                    },
                    Ordering::Greater => {
                        RemoveMethod::Partial(stacked_inventory_item.tool)
                    },
                    Ordering::Less => {
                        return Err(InventoryItemConsumeError::InvalidAmount)
                    }
                }
            },
        };

        match remove_method {
            RemoveMethod::EntireThing(consumed_item) => {
                self.inventory.items.remove(self.slot);
                Ok(consumed_item)
            },
            RemoveMethod::Partial(tool) => {
                let entity_ids = self.inventory.items.get_mut(self.slot)
                    .and_then(|item| {
                        if let InventoryItem::Stacked(stacked_inventory_item) = item {
                            Some(stacked_inventory_item.entity_ids.drain(..amount).collect::<Vec<_>>())
                        }
                        else {
                            None
                        }
                    })
                    .ok_or(InventoryItemConsumeError::InvalidAmount)?;
                Ok(ConsumedItem::Stacked(StackedConsumedItem {
                    entity_ids,
                    tool,
                }))
            }
        }
    }

    pub fn get_slot(&self) -> usize {
        self.slot
    }
}




#[derive(Debug)]
pub struct CharacterInventory {
    item_id_counter: u32,
    items: Vec<InventoryItem>,
    equipped: EquippedEntity,
}

impl CharacterInventory {
    pub fn new(items: Vec<InventoryItem>, equipped: &EquippedEntity) -> CharacterInventory {
        CharacterInventory{
            item_id_counter: 0,
            items,
            equipped: equipped.clone(),
        }
    }

    pub fn initialize_item_ids(&mut self, base_item_id: u32) {
        for (i, item) in self.items.iter_mut().enumerate() {
            item.set_item_id(ClientItemId(base_item_id + i as u32));
        }
        self.item_id_counter = base_item_id + self.items.len() as u32 + 1;
    }

    pub fn as_client_inventory_items(&self) -> [character::InventoryItem; 30] {
        self.items.iter()
            .enumerate()
            .fold([character::InventoryItem::default(); 30], |mut inventory, (slot, item)| {
                let bytes = item.as_client_bytes();
                inventory[slot].data1.copy_from_slice(&bytes[0..12]);
                inventory[slot].data2.copy_from_slice(&bytes[12..16]);
                inventory[slot].item_id = item.item_id().0;
                inventory[slot].equipped = 0;
                inventory[slot].flags = 0;

                if let InventoryItem::Individual(individual_item) = item {
                    if self.equipped.is_equipped(&individual_item.entity_id) {
                        if let ItemDetail::Unit(_) = individual_item.item {
                            inventory[slot].data1[4] = self.equipped.unit.iter()
                                .enumerate()
                                .find(|(_, u_id)| **u_id == Some(individual_item.entity_id))
                                .map(|(a, _)| a)
                                .unwrap_or(0) as u8
                        }
                        inventory[slot].equipped = 1;
                        inventory[slot].flags |= 8;
                    }
                }
                inventory
            })
    }

    pub fn slot(&self, slot: usize) -> Option<&InventoryItem> {
        self.items.get(slot)
    }

    pub fn count(&self) -> usize {
        self.items.len()
    }

    pub fn space_for_individual_item(&self) -> bool {
        self.count() < INVENTORY_CAPACITY
    }

    pub fn space_for_stacked_item(&self, tool: &Tool, amount: usize) -> SpaceForStack {
        let existing_item = self.items.iter()
            .filter_map(|item| {
                match item {
                    InventoryItem::Stacked(s_item) => {
                        Some(s_item)
                    },
                    _ => None
                }
            })
            .find(|s_item| {
                s_item.tool == *tool
            });

        match existing_item {
            Some(item) => {
                if item.count() + amount <= tool.tool.max_stack() {
                    SpaceForStack::Yes(YesThereIsSpace::ExistingStack)
                }
                else {
                    SpaceForStack::No(NoThereIsNotSpace::FullStack)
                }
            }
            None => {
                if self.count() < INVENTORY_CAPACITY  {
                    SpaceForStack::Yes(YesThereIsSpace::NewStack)
                }
                else {
                    SpaceForStack::No(NoThereIsNotSpace::FullInventory)
                }
            }
        }
    }

    pub fn stack_item_id(&self, tool: &Tool) -> Option<ClientItemId> {
        self.items.iter()
            .filter_map(|item| {
                match item {
                    InventoryItem::Stacked(s_item) => {
                        Some(s_item)
                    },
                    _ => None
                }
            })
            .find(|s_item| {
                s_item.tool == *tool
            })
            .map(|item| {
                item.item_id
            })
    }

    pub fn get_item_handle_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItemHandle> {
        let (slot, _) = self.items.iter()
            .enumerate()
            .find(|(_, item)| {
                item.item_id() == item_id
            })?;
        Some(InventoryItemHandle {
            inventory: self,
            slot,
        })
    }

    pub fn get_equipped_mag_handle(&mut self) -> Option<InventoryItemHandle> {
        let (slot, _) = self.items.iter()
            .enumerate()
            .find(|(_, item)| {
                if let InventoryItem::Individual(individual_inventory_item) = item {
                    if let ItemDetail::Mag(_) = &individual_inventory_item.item {
                        return self.equipped.is_equipped(&individual_inventory_item.entity_id)
                    }
                }
                false
            })?;
        Some(InventoryItemHandle {
            inventory: self,
            slot,
        })
    }

    pub fn get_equipped_armor_handle(&mut self) -> Option<InventoryItemHandle> {
        let (slot, _) = self.items.iter()
            .enumerate()
            .find(|(_, item)| {
                if let InventoryItem::Individual(individual_inventory_item) = item {
                    if let ItemDetail::Armor(_) = &individual_inventory_item.item {
                        return self.equipped.is_equipped(&individual_inventory_item.entity_id)
                    }
                }
                false
            })?;
        Some(InventoryItemHandle {
            inventory: self,
            slot,
        })
    }

    pub fn get_equipped_shield_handle(&mut self) -> Option<InventoryItemHandle> {
        let (slot, _) = self.items.iter()
            .enumerate()
            .find(|(_, item)| {
                if let InventoryItem::Individual(individual_inventory_item) = item {
                    if let ItemDetail::Shield(_) = &individual_inventory_item.item {
                        return self.equipped.is_equipped(&individual_inventory_item.entity_id)
                    }
                }
                false
            })?;
        Some(InventoryItemHandle {
            inventory: self,
            slot,
        })
    }

    pub fn get_equipped_weapon_handle(&mut self) -> Option<InventoryItemHandle> {
        let (slot, _) = self.items.iter()
            .enumerate()
            .find(|(_, item)| {
                if let InventoryItem::Individual(individual_inventory_item) = item {
                    if let ItemDetail::Weapon(_) = &individual_inventory_item.item {
                        return self.equipped.is_equipped(&individual_inventory_item.entity_id)
                    }
                }
                false
            })?;
        Some(InventoryItemHandle {
            inventory: self,
            slot,
        })
    }

    pub fn get_item_by_id(&self, item_id: ClientItemId) -> Option<&InventoryItem> {
        self.items.iter()
            .find(|item| {
                item.item_id() == item_id
            })
    }

    pub fn take_item_by_id(&mut self, item_id: ClientItemId) -> Option<InventoryItem> {
        self.items
            .drain_filter(|i| i.item_id() == item_id)
            .next()
    }

    pub fn take_stacked_item_by_id(&mut self, item_id: ClientItemId, amount: usize) -> Option<StackedInventoryItem> {
        let idx = self.items
            .iter_mut()
            .position(|i| i.item_id() == item_id)?;
        let item: &mut StackedInventoryItem = self.items.get_mut(idx)?.stacked_mut()?;
        match item.entity_ids.len().cmp(&amount) {
            Ordering::Equal => {
                let item = self.items.remove(idx);
                item.stacked().cloned()
            },
            Ordering::Greater => {
                let entity_ids = item.entity_ids.drain(..amount).collect();
                Some(StackedInventoryItem {
                    entity_ids,
                    tool: item.tool,
                    item_id: item.item_id,
                })
            },
            Ordering::Less => {
                None
            }
        }
    }

    pub fn add_item(&mut self, item: InventoryItem) {
        self.items.push(item);
    }

    pub fn add_stacked_item(&mut self, mut item: StackedInventoryItem) {
        let existing_item = self.items
            .iter_mut()
            .filter_map(|i| {
                match i {
                    InventoryItem::Stacked(stacked) => {
                        Some(stacked)
                    },
                    _ => None
                }
            })
            .find(|i| {
                i.tool == item.tool
            });

        match existing_item {
            Some(existing_item) => {
                existing_item.entity_ids.append(&mut item.entity_ids)
            },
            None => {
                self.items.push(InventoryItem::Stacked(item))
            }
        }
    }

    pub fn add_item_with_new_item_id(&mut self, item: InventoryItem, item_id: ClientItemId) {
        match item {
            InventoryItem::Individual(mut individual_inventory_item) => {
                individual_inventory_item.item_id = item_id;
                self.add_item(InventoryItem::Individual(individual_inventory_item));
            },
            InventoryItem::Stacked(mut stacked_inventory_item) => {
                stacked_inventory_item.item_id = item_id;
                self.add_stacked_item(stacked_inventory_item)
            }
        }
    }

    pub fn add_individual_floor_item(&mut self, floor_item: &IndividualFloorItem) -> &InventoryItem {
        self.items.push(InventoryItem::Individual(IndividualInventoryItem {
            entity_id: floor_item.entity_id,
            item_id: floor_item.item_id,
            item: floor_item.item.clone(),
        }));

        self.items.last().unwrap()
    }

    // TODO: should these pick up functions take floor_item as mut and remove the ids?
    pub fn pick_up_individual_floor_item(&mut self, floor_item: &IndividualFloorItem) -> Option<(&IndividualInventoryItem, InventorySlot)> {
        if self.count() >= 30 {
            return None;
        }

        self.items.push(InventoryItem::Individual(IndividualInventoryItem {
            entity_id: floor_item.entity_id,
            item_id: floor_item.item_id,
            item: floor_item.item.clone(),
        }));

        if let Some(InventoryItem::Individual(new_item)) = self.items.last() {
            Some((new_item, InventorySlot(self.count()-1)))
        }
        else {
            None
        }
    }

    pub fn add_stacked_floor_item(&mut self, floor_item: &StackedFloorItem) {
        let existing_item = self.items.iter_mut()
            .filter_map(|item| {
                match item {
                    InventoryItem::Stacked(s_item) => Some(s_item),
                    _ => None,
                }

            })
            .find(|item| {
                item.tool == floor_item.tool
            });

        match existing_item {
            Some(item) => {
                item.entity_ids.append(&mut floor_item.entity_ids.clone())
            },
            None => {
                self.items.push(InventoryItem::Stacked(StackedInventoryItem {
                    entity_ids: floor_item.entity_ids.clone(),
                    item_id: floor_item.item_id,
                    tool: floor_item.tool,
                }));
            }
        }
    }

    // TODO: can be simplified using find instead of position
    pub fn pick_up_stacked_floor_item(&mut self, floor_item: &StackedFloorItem) -> Option<(&StackedInventoryItem, InventorySlot)> {
        let existing_stack_position = self.items.iter()
            .position(|inventory_item| {
                if let InventoryItem::Stacked(stacked_inventory_item) = inventory_item {
                    if stacked_inventory_item.tool == floor_item.tool {
                        return true
                    }
                }
                false
            });

        if let Some(existing_stack_position) = existing_stack_position {
            if let Some(InventoryItem::Stacked(stacked_item)) = self.items.get_mut(existing_stack_position) {
                if stacked_item.count() + floor_item.count() <= stacked_item.tool.max_stack() {
                    stacked_item.entity_ids.append(&mut floor_item.entity_ids.clone());
                    Some((stacked_item, InventorySlot(existing_stack_position)))
                }
                else {
                    None
                }
            }
            else {
                None
            }
        }
        else {
            let new_stacked_item = InventoryItem::Stacked(StackedInventoryItem {
                entity_ids: floor_item.entity_ids.clone(),
                item_id: floor_item.item_id,
                tool: floor_item.tool,
            });

            self.items.push(new_stacked_item);
            if let Some(InventoryItem::Stacked(new_item)) = self.items.last() {
                Some((new_item, InventorySlot(self.count()-1)))
            }
            else {
                None
            }
        }
    }

    pub fn withdraw_item(&mut self, mut bank_item: BankItemHandle, amount: usize) -> Option<(&InventoryItem, usize)> {
        let (remove, slot) = match bank_item.item_mut()? {
            BankItem::Individual(individual_bank_item) => {
                if self.items.len() >= INVENTORY_CAPACITY {
                    return None
                }
                self.items.push(InventoryItem::Individual(IndividualInventoryItem {
                    entity_id: individual_bank_item.entity_id,
                    item_id: individual_bank_item.item_id,
                    item: individual_bank_item.item.clone(),
                }));
                (true, self.count()-1)
            },
            BankItem::Stacked(stacked_bank_item) => {
                let existing_inventory_item = self.items.iter_mut()
                    .enumerate()
                    .find_map(|(index, item)| {
                        if let InventoryItem::Stacked(stacked_inventory_item) = item {
                            if stacked_bank_item.tool == stacked_inventory_item.tool {
                                return Some((index, stacked_inventory_item))
                            }
                        }
                        None
                    });

                let slot = match existing_inventory_item {
                    Some((slot, stacked_inventory_item)) => {
                        if stacked_inventory_item.count() + stacked_bank_item.count() > stacked_bank_item.tool.max_stack() {
                            return None
                        }

                        let mut withdrawn_entity_ids = stacked_bank_item.take_entity_ids(amount)?;
                        stacked_inventory_item.entity_ids.append(&mut withdrawn_entity_ids);
                        slot
                    }
                    None => {
                        if self.items.len() >= INVENTORY_CAPACITY {
                            return None
                        }
                        let withdrawn_entity_ids = stacked_bank_item.take_entity_ids(amount)?;

                        self.item_id_counter += 1; // oh no
                        self.items.push(InventoryItem::Stacked(StackedInventoryItem {
                            entity_ids: withdrawn_entity_ids,
                            item_id: ClientItemId(self.item_id_counter),
                            tool: stacked_bank_item.tool,
                        }));
                        self.count()-1
                    }
                };
                (stacked_bank_item.count() == 0, slot)
            }
        };

        if remove {
            bank_item.remove_from_bank();
        }

        self.items.last().map(|item| {
            (item, slot)
        })
    }

    pub fn iter(&self) -> impl Iterator<Item = &InventoryItem> {
        self.items.iter()
    }

    pub fn items(&self) -> &Vec<InventoryItem> {
        &self.items
    }

    pub fn set_items(&mut self, sorted_items: Vec<InventoryItem>) {
        self.items = sorted_items;
    }

    pub fn remove_by_id(&mut self, id: ClientItemId) -> Option<InventoryItem> {
        self.items.iter()
            .position(|i| i.item_id() == id)
            .map(|position| {
                self.items.remove(position)
            })
    }

    pub fn equip(&mut self, id: &ClientItemId, equip_slot: u8) {
        for item in &self.items {
            if let InventoryItem::Individual(inventory_item) = item {
                if inventory_item.item_id == *id {
                    match inventory_item.item {
                        ItemDetail::Weapon(_) => self.equipped.weapon = Some(inventory_item.entity_id),
                        ItemDetail::Armor(_) => self.equipped.armor = Some(inventory_item.entity_id),
                        ItemDetail::Shield(_) => self.equipped.shield = Some(inventory_item.entity_id),
                        ItemDetail::Unit(_) => {
                            if let Some(unit) = self.equipped.unit.get_mut(equip_slot as usize) {
                                *unit = Some(inventory_item.entity_id)
                            }
                        }
                        ItemDetail::Mag(_) => self.equipped.mag = Some(inventory_item.entity_id),
                        _ => {}
                    }
                }
            }
        }
    }

    pub fn unequip(&mut self, id: &ClientItemId) {
        for item in &self.items {
            if let InventoryItem::Individual(inventory_item) = item {
                if inventory_item.item_id == *id {
                    match inventory_item.item {
                        ItemDetail::Weapon(_) => self.equipped.weapon = None,
                        ItemDetail::Armor(_) => {
                            self.equipped.armor = None;
                            self.equipped.unit = [None; 4];
                        }
                        ItemDetail::Shield(_) => self.equipped.shield = None,
                        ItemDetail::Unit(_) => {
                            for unit in self.equipped.unit.iter_mut() {
                                if *unit == Some(inventory_item.entity_id) {
                                    *unit = None
                                }
                            }
                        }
                        ItemDetail::Mag(_) => self.equipped.mag = Some(inventory_item.entity_id),
                        _ => {}
                    }
                }
            }
        }
    }

    pub fn as_inventory_entity(&self, _character_id: &CharacterEntityId) -> InventoryEntity {
        InventoryEntity {
            items: self.items.iter()
                .map(|item| {
                    match item {
                        InventoryItem::Individual(item) => {
                            InventoryItemEntity::Individual(ItemEntity {
                                id: item.entity_id,
                                item: item.item.clone(),
                            })
                        },
                        InventoryItem::Stacked(items) => {
                            InventoryItemEntity::Stacked(items.entity_ids.iter()
                                                         .map(|id| {
                                                             ItemEntity {
                                                                 id: *id,
                                                                 item: ItemDetail::Tool(items.tool)
                                                             }
                                                         })
                                                         .collect())
                        },
                    }
                })
                .collect()
        }
    }

    pub fn as_equipped_entity(&self) -> EquippedEntity {
        self.equipped.clone()
    }
}