use std::cmp::Ordering;
use thiserror::Error;
use libpso::character::character;//::InventoryItem;
use crate::entity::item::{ItemEntityId, ItemDetail};
use crate::entity::item::tool::Tool;
use crate::ship::items::ClientItemId;
use crate::ship::items::floor::{IndividualFloorItem, StackedFloorItem};


#[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,
    pub equipped: bool,
}

#[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()
    }
}

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

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

impl InventoryItem {
    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 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
        }
    }

    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
    pub fn combine_stacks(&mut self, other_stacked_item: &mut StackedFloorItem) {
        match self {
            InventoryItem::Stacked(self_stacked_item) => {
                self_stacked_item.entity_ids.append(&mut other_stacked_item.entity_ids);
            },
            _ => {
            }
        }
    }

    pub fn equipped(&self) -> bool {
        match self {
            InventoryItem::Individual(individual_inventory_item) => {
                individual_inventory_item.equipped
            },
            InventoryItem::Stacked(_) => {
                false
            }
        }
    }

    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(),
                }
            },
            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(())
    }
}


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

pub struct ConsumedItem {
    pub entity_ids: Vec<ItemEntityId>,
    pub item: ItemDetail
}

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

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

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

    pub fn consume(self, amount: usize) -> Result<ConsumedItem, InventoryItemConsumeError> {
        enum RemoveMethod {
            EntireThing(ConsumedItem),
            Partial(ItemDetail),
        }
        
        let inventory_item = self.inventory.0.get(self.slot).ok_or(InventoryItemConsumeError::InconsistentState)?;
        let remove_method = match inventory_item {
            InventoryItem::Individual(individual_inventory_item) => {
                RemoveMethod::EntireThing(ConsumedItem {
                    entity_ids: vec![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 {
                            entity_ids: stacked_inventory_item.entity_ids.clone(),
                            item: ItemDetail::Tool(stacked_inventory_item.tool),
                        })
                    },
                    Ordering::Greater => {
                        RemoveMethod::Partial(ItemDetail::Tool(stacked_inventory_item.tool))
                    },
                    Ordering::Less => {
                        return Err(InventoryItemConsumeError::InvalidAmount)
                    }
                }
            },
        };

        match remove_method {
            RemoveMethod::EntireThing(consumed_item) => {
                self.inventory.0.remove(self.slot);
                Ok(consumed_item)
            },
            RemoveMethod::Partial(item_detail) => {
                let entity_ids = self.inventory.0.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 {
                    entity_ids: entity_ids,
                    item: item_detail,
                })
            }
        }
    } 
}




#[derive(Debug)]
pub struct CharacterInventory(Vec<InventoryItem>);

impl CharacterInventory {
    pub fn new(items: Vec<InventoryItem>) -> CharacterInventory {
        CharacterInventory(items)
    }

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

    pub fn as_client_inventory_items(&self) -> [character::InventoryItem; 30] {
        self.0.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;
                // does this do anything?
                inventory[slot].equipped = if item.equipped() { 1 } else { 0 };
                // because this actually equips the item
                inventory[slot].flags |= if item.equipped() { 8 } else { 0 };
                inventory
            })
    }

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

    pub fn count(&self) -> usize {
        self.0.len()
    }
    
    pub fn get_item_handle_by_id<'a>(&'a mut self, item_id: ClientItemId) -> Option<InventoryItemHandle<'a>> {
        let (slot, _) = self.0.iter()
            .enumerate()
            .filter(|(_, item)| {
                item.item_id() == item_id
            })
            .nth(0)?;
        Some(InventoryItemHandle {
            inventory: self,
            slot: slot,
        })
    }

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

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

    pub fn add_item(&mut self, item: InventoryItem) -> Result<(), ()> { // TODO: errors
        // TODO: check slot conflict?
        self.0.push(item);
        Ok(())
    }

    // 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.0.push(InventoryItem::Individual(IndividualInventoryItem {
            entity_id: floor_item.entity_id,
            item_id: floor_item.item_id,
            item: floor_item.item.clone(),
            equipped: false,
        }));

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

    // 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.0.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.0.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.0.push(new_stacked_item);
            if let Some(InventoryItem::Stacked(new_item)) = self.0.last() {
                Some((new_item, InventorySlot(self.count())))
            }
            else {
                None
            }
        }
    }
}