use log::warn;
use rand::Rng;
use rand::seq::SliceRandom;
use libpso::packet::ship::*;
use libpso::packet::messages::*;
use crate::common::leveltable::CharacterLevelTable;
use crate::common::serverstate::ClientId;
use crate::ship::ship::{SendShipPacket, ShipError, Clients, Rooms, ItemShops};
use crate::ship::location::{ClientLocation, ClientLocationError};
use crate::ship::drops::ItemDrop;
use crate::ship::items::ClientItemId;
use crate::entity::gateway::EntityGateway;
use crate::entity::item;
use libpso::utf8_to_utf16_array;
use crate::ship::packet::builder;
use crate::ship::shops::{ShopItem, ToolShopItem, ArmorShopItem};
use crate::ship::items::state::{ItemState, ItemStateError};
use crate::ship::items::floor::{FloorType, FloorItemDetail};
use crate::ship::items::actions::TriggerCreateItem;
use crate::ship::items::tasks::{pick_up_item, withdraw_meseta, deposit_meseta, withdraw_item, deposit_item, buy_shop_item, enemy_drops_item, take_meseta, apply_modifier};

const BANK_ACTION_DEPOSIT: u8 = 0;
const BANK_ACTION_WITHDRAW: u8 = 1;

const SHOP_OPTION_TOOL: u8 = 0;
const SHOP_OPTION_WEAPON: u8 = 1;
const SHOP_OPTION_ARMOR: u8 = 2;

#[derive(thiserror::Error, Debug)]
pub enum MessageError {
    #[error("invalid tek {0}")]
    InvalidTek(ClientItemId),
    #[error("mismatched tek {0} {1}")]
    MismatchedTekIds(ClientItemId, ClientItemId),
}

fn send_to_client(id: ClientId, target: u8, msg: DirectMessage, client_location: &ClientLocation)
                  -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    Box::new(client_location.get_all_clients_by_client(id).unwrap().into_iter()
             .filter(move |client| client.local_client.id() == target)
             .map(move |client| {
                 (client.client, SendShipPacket::DirectMessage(msg.clone()))
             }))
}

pub fn guildcard_send(id: ClientId,
                      guildcard_send: &GuildcardSend,
                      target: u32,
                      client_location: &ClientLocation,
                      clients: &Clients)
                      -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let client = clients.get(&id).unwrap();
    let msg = DirectMessage{
        flag: target,
        msg: GameMessage::GuildcardRecv(GuildcardRecv {
            client: guildcard_send.client,
            target: guildcard_send.target,
            guildcard: client.user.id.0,
            name: utf8_to_utf16_array!(client.character.name, 0x18),
            team: [0; 0x10], // TODO: teams not yet implemented
            desc: utf8_to_utf16_array!(client.character.guildcard.description, 0x58),
            one: 1,
            language: 0, // TODO: add language flag to character
            section_id: client.character.section_id.into(),
            class: client.character.char_class.into(),
        }),
    };
    send_to_client(id, target as u8, msg, client_location)
}

pub async fn request_item<EG>(id: ClientId,
                              request_item: &RequestItem,
                              entity_gateway: &mut EG,
                              client_location: &ClientLocation,
                              clients: &mut Clients,
                              rooms: &mut Rooms,
                              item_state: &mut ItemState)
                              -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?
        .as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;

    let monster = room.maps.enemy_by_id(request_item.enemy_id as usize)?;
    if monster.dropped_item {
        return Err(ShipError::MonsterAlreadyDroppedItem(id, request_item.enemy_id).into())
    }

    let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;

    let client_and_drop = clients_in_area.into_iter()
        .filter_map(|area_client| {
            room.drop_table.get_drop(&monster.map_area, &monster.monster).map(|item_drop_type| {
                (area_client, item_drop_type)
            })
        });

    let mut item_drop_packets = Vec::new();
    for (area_client, item_drop) in client_and_drop {
        let item_drop = ItemDrop {
            map_area: monster.map_area,
            x: request_item.x,
            y: request_item.y,
            z: request_item.z,
            item: item_drop,
        };
        let client = clients.get_mut(&area_client.client).ok_or(ShipError::ClientNotFound(area_client.client))?;
        let floor_item = enemy_drops_item(item_state, entity_gateway, client.character.id, item_drop).await?;
        let item_drop_msg = builder::message::item_drop(request_item.client, request_item.target, &floor_item)?;

        item_drop_packets.push((area_client.client, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(item_drop_msg)))));
    }

    Ok(Box::new(item_drop_packets.into_iter()))
}

pub async fn pickup_item<EG>(id: ClientId,
                             pickup_item: &PickupItem,
                             entity_gateway: &mut EG,
                             client_location: &ClientLocation,
                             clients: &mut Clients,
                             item_state: &mut ItemState)
                             -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;

    // TODO: should not need to fetch the item here to construct this packet
    //let (item, floor_type) = item_manager.get_floor_item_by_id(&client.character, ClientItemId(pickup_item.item_id))?;
    /*
    let (item, floor_type) = item_state.get_floor_item(&client.character, &ClientItemId(pickup_item.item_id))?;
    let remove_item = builder::message::remove_item_from_floor(area_client, item)?;
    let create_item = match item {
        FloorItem::Individual(individual_floor_item) => Some(builder::message::create_individual_item(area_client, item.item_id(), &individual_floor_item.item)?),
        FloorItem::Stacked(stacked_floor_item) => Some(builder::message::create_stacked_item(area_client, item.item_id(), &stacked_floor_item.tool, stacked_floor_item.count())?),
        FloorItem::Meseta(_) => None,
        //_ => Some(builder::message::create_item(area_client, &item)?),
    };
     */

    let (item, floor_type) = item_state.get_floor_item(&client.character.id, &ClientItemId(pickup_item.item_id))?;
    let remove_item = builder::message::remove_item_from_floor(area_client, item)?;
    let create_item = match &item.item {
        FloorItemDetail::Individual(individual_floor_item) => Some(builder::message::create_individual_item(area_client, item.item_id, individual_floor_item)?),
        FloorItemDetail::Stacked(stacked_floor_item) => Some(builder::message::create_stacked_item(area_client, item.item_id, &stacked_floor_item.tool, stacked_floor_item.count())?),
        FloorItemDetail::Meseta(_) => None,
        //_ => Some(builder::message::create_item(area_client, &item)?),
    };

    //match item_manager.character_picks_up_item(entity_gateway, &mut client.character, ClientItemId(pickup_item.item_id)).await {
    match pick_up_item(item_state, entity_gateway, &client.character, &ClientItemId(pickup_item.item_id)).await {
        Ok(trigger_create_item) => {
            let remove_packets: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = match floor_type {
                FloorType::Local => {
                    Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::RemoveItemFromFloor(remove_item.clone()))))].into_iter())
                },
                FloorType::Shared => {
                    Box::new(clients_in_area.clone().into_iter()
                        .map(move |c| {
                            (c.client, SendShipPacket::Message(Message::new(GameMessage::RemoveItemFromFloor(remove_item.clone()))))
                        }))
                },
            };

            Ok(Box::new(remove_packets
                        .chain(clients_in_area.into_iter().
                               filter_map(move |c| {
                                   match trigger_create_item {
                                       TriggerCreateItem::Yes => create_item.clone().map(|ci| (c.client, SendShipPacket::Message(Message::new(GameMessage::CreateItem(ci))))),
                                       _ => None
                                   }
                               }
                               ))))
        },
        Err(err) => {
            warn!("character {:?} could not pick up item: {:?}", client.character.id, err);
            Ok(Box::new(None.into_iter()))
        },
    }
}

pub async fn request_box_item<EG>(id: ClientId,
    box_drop_request: &BoxDropRequest,
    entity_gateway: &mut EG,
    client_location: &ClientLocation,
    clients: &mut Clients,
    rooms: &mut Rooms,
    item_state: &mut ItemState)
    -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
EG: EntityGateway
{
    let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get_mut(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?
        .as_mut()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;

    let box_object = room.maps.object_by_id(box_drop_request.object_id as usize)?;
    if box_object.dropped_item {
        return Err(ShipError::BoxAlreadyDroppedItem(id, box_drop_request.object_id).into())
    }

    let clients_in_area = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;

    let client_and_drop = clients_in_area.into_iter()
        .filter_map(|area_client| {
            room.drop_table.get_box_drop(&box_object.map, &box_object).map(|item_drop_type| {
                (area_client, item_drop_type)
            })
        });

    let mut item_drop_packets = Vec::new();
    for (area_client, item_drop) in client_and_drop {
        let item_drop = ItemDrop {
            map_area: box_object.map,
            x: box_drop_request.x,
            y: 0.0,
            z: box_drop_request.z,
            item: item_drop,
        };
        let client = clients.get_mut(&area_client.client).ok_or(ShipError::ClientNotFound(area_client.client))?;
        let floor_item = enemy_drops_item(item_state, entity_gateway, client.character.id, item_drop).await?;
        let item_drop_msg = builder::message::item_drop(box_drop_request.client, box_drop_request.target, &floor_item)?;
        item_drop_packets.push((area_client.client, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(item_drop_msg)))))
    }

    Ok(Box::new(item_drop_packets.into_iter()))
}


// item_manager is not mutable in this, but for reasons I don't quite understand it requires the unique access of it to compile here
pub async fn send_bank_list(id: ClientId,
                            clients: &Clients,
                            item_state: &mut ItemState)
                            -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
{
    let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
    let bank = item_state.get_character_bank(&client.character)?;
    let bank_items_pkt = builder::message::bank_item_list(bank);
    Ok(Box::new(vec![(id, SendShipPacket::BankItemList(bank_items_pkt))].into_iter()))
}

pub async fn bank_interaction<EG>(id: ClientId,
                                  bank_interaction: &BankInteraction,
                                  entity_gateway: &mut EG,
                                  client_location: &ClientLocation,
                                  clients: &mut Clients,
                                  item_state: &mut ItemState)
                                  -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let other_clients_in_area = client_location.get_all_clients_by_client(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let bank_action_pkts = match bank_interaction.action {
        BANK_ACTION_DEPOSIT => {
            if bank_interaction.item_id == 0xFFFFFFFF {
                deposit_meseta(item_state, entity_gateway, &client.character, bank_interaction.meseta_amount).await?;
                Vec::new()
            }
            else {
                deposit_item(item_state, entity_gateway, &client.character, &ClientItemId(bank_interaction.item_id), bank_interaction.item_amount as u32).await?;
                let player_no_longer_has_item = builder::message::player_no_longer_has_item(area_client, ClientItemId(bank_interaction.item_id), bank_interaction.item_amount as u32);
                vec![SendShipPacket::Message(Message::new(GameMessage::PlayerNoLongerHasItem(player_no_longer_has_item)))]
            }
        },
        BANK_ACTION_WITHDRAW => {
            if bank_interaction.item_id == 0xFFFFFFFF {
                withdraw_meseta(item_state, entity_gateway, &client.character, bank_interaction.meseta_amount).await?;
                Vec::new()
            }
            else {
                let item_added_to_inventory = withdraw_item(item_state, entity_gateway, &client.character, &ClientItemId(bank_interaction.item_id), bank_interaction.item_amount as u32).await?;
                let item_created = builder::message::create_withdrawn_inventory_item2(area_client, &item_added_to_inventory)?;
                vec![SendShipPacket::Message(Message::new(GameMessage::CreateItem(item_created)))]
            }
        },
        _ => { // TODO: error?
            Vec::new()
        }
    };

    Ok(Box::new(other_clients_in_area.into_iter()
                .flat_map(move |c| {
                    bank_action_pkts.clone().into_iter()
                        .map(move |pkt| {
                            (c.client, pkt)
                        })
                })
    ))
}

pub async fn shop_request(id: ClientId,
                          shop_request: &ShopRequest,
                          client_location: &ClientLocation,
                          clients: &mut Clients,
                          rooms: &Rooms,
                          level_table: &CharacterLevelTable,
                          shops: &mut ItemShops)
                          -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    let room_id = client_location.get_room(id).map_err(|err| -> ClientLocationError { err.into() })?;
    let room = rooms.get(room_id.0)
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?
        .as_ref()
        .ok_or(ShipError::InvalidRoom(room_id.0 as u32))?;
    let level = level_table.get_level_from_exp(client.character.char_class, client.character.exp) as usize;
    let shop_list = match shop_request.shop_type {
        SHOP_OPTION_WEAPON => {
            client.weapon_shop = shops.weapon_shop.get_mut(&(room.mode.difficulty(), client.character.section_id))
                .ok_or(ShipError::ShopError)?
                .generate_weapon_list(level);
            builder::message::shop_list(shop_request.shop_type, &client.weapon_shop)
        },
        SHOP_OPTION_TOOL => {
            client.tool_shop = shops.tool_shop.generate_tool_list(level);
            builder::message::shop_list(shop_request.shop_type, &client.tool_shop)
        },
        SHOP_OPTION_ARMOR => {
            client.armor_shop = shops.armor_shop.generate_armor_list(level);
            builder::message::shop_list(shop_request.shop_type, &client.armor_shop)
        },
        _ => {
            return Err(ShipError::ShopError.into())
        }
    };

    Ok(Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::ShopList(shop_list))))].into_iter()))
}


pub async fn buy_item<EG>(id: ClientId,
                          buy_item: &BuyItem,
                          entity_gateway: &mut EG,
                          client_location: &ClientLocation,
                          clients: &mut Clients,
                          item_state: &mut ItemState)
                          -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;

    let (item, remove): (&(dyn ShopItem + Send + Sync), bool) = match buy_item.shop_type {
        SHOP_OPTION_WEAPON => {
            (client.weapon_shop.get(buy_item.shop_index as usize).ok_or(ShipError::ShopError)?, false)
        },
        SHOP_OPTION_TOOL => {
            let item = client.tool_shop.get(buy_item.shop_index as usize).ok_or(ShipError::ShopError)?;
            let remove = matches!(item, ToolShopItem::Tech(_));
            (item, remove)
        },
        SHOP_OPTION_ARMOR => {
            let item = client.armor_shop.get(buy_item.shop_index as usize).ok_or(ShipError::ShopError)?;
            let remove = matches!(item, ArmorShopItem::Unit(_));
            (item, remove)
        },
        _ => {
            return Err(ShipError::ShopError.into())
        }
    };

    let inventory_item = buy_shop_item(item_state, entity_gateway, &client.character, item, ClientItemId(buy_item.item_id), buy_item.amount as u32).await?;
    let create = builder::message::create_withdrawn_inventory_item(area_client, &inventory_item)?;

    if remove {
        match buy_item.shop_type {
            SHOP_OPTION_TOOL => {
                client.tool_shop.remove(buy_item.shop_index as usize);
            },
            SHOP_OPTION_ARMOR => {
                client.armor_shop.remove(buy_item.shop_index as usize);
            },
            _ => {}
        }
    }

    let other_clients_in_area = client_location.get_client_neighbors(id).map_err(|err| -> ClientLocationError { err.into() })?;
    Ok(Box::new(other_clients_in_area.into_iter()
                .map(move |c| {
                    (c.client, SendShipPacket::Message(Message::new(GameMessage::CreateItem(create.clone()))))
                })))

}


const TEK_SPECIAL_MODIFIER: [item::weapon::TekSpecialModifier; 3] = [item::weapon::TekSpecialModifier::Plus,
                                                                     item::weapon::TekSpecialModifier::Neutral,
                                                                     item::weapon::TekSpecialModifier::Minus];
const TEK_PERCENT_MODIFIER: [item::weapon::TekPercentModifier; 5] = [item::weapon::TekPercentModifier::PlusPlus,
                                                                     item::weapon::TekPercentModifier::Plus,
                                                                     item::weapon::TekPercentModifier::Neutral,
                                                                     item::weapon::TekPercentModifier::Minus,
                                                                     item::weapon::TekPercentModifier::MinusMinus];

pub async fn request_tek_item<EG>(id: ClientId,
                                  tek_request: &TekRequest,
                                  entity_gateway: &mut EG,
                                  clients: &mut Clients,
                                  item_state: &mut ItemState)
                                  -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;

    let (grind_mod, special_mod, percent_mod) = {
        let mut rng = rand::thread_rng();

        let grind_mod = rng.gen_range(-4, 4);
        let special_mod = TEK_SPECIAL_MODIFIER.choose(&mut rng).cloned().unwrap();
        let percent_mod = TEK_PERCENT_MODIFIER.choose(&mut rng).cloned().unwrap();
        (grind_mod, special_mod, percent_mod)
    };

    client.tek = Some((ClientItemId(tek_request.item_id), special_mod, percent_mod, grind_mod));

    let inventory = item_state.get_character_inventory(&client.character)?;
    let item = inventory.get_by_client_id(&ClientItemId(tek_request.item_id))
        .ok_or(ItemStateError::WrongItemType(ClientItemId(tek_request.item_id)))?;
    let mut weapon = *item.item.as_individual()
        .ok_or(ItemStateError::WrongItemType(ClientItemId(tek_request.item_id)))?
        .as_weapon()
        .ok_or(ItemStateError::WrongItemType(ClientItemId(tek_request.item_id)))?;

    weapon.apply_modifier(&item::weapon::WeaponModifier::Tekked {
        special: special_mod,
        percent: percent_mod,
        grind: grind_mod,
    });

    take_meseta(item_state, entity_gateway, &client.character.id, item::Meseta(100)).await?;

    let preview_pkt = builder::message::tek_preview(ClientItemId(tek_request.item_id), &weapon)?;

    Ok(Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::TekPreview(preview_pkt))))].into_iter()))
}

pub async fn accept_tek_item<EG>(id: ClientId,
                                 tek_accept: &TekAccept,
                                 entity_gateway: &mut EG,
                                 client_location: &ClientLocation,
                                 clients: &mut Clients,
                                 item_state: &mut ItemState)
                                 -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, anyhow::Error>
where
    EG: EntityGateway
{
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;

    if let Some((item_id, special_mod, percent_mod, grind_mod)) = client.tek {
        if item_id.0 != tek_accept.item_id {
            return Err(MessageError::MismatchedTekIds(item_id, ClientItemId(tek_accept.item_id)).into());
        }

        let modifier = item::weapon::WeaponModifier::Tekked {
            special: special_mod,
            percent: percent_mod,
            grind: grind_mod,
        };
        let weapon = apply_modifier(item_state, entity_gateway, &client.character, item_id, item::ItemModifier::WeaponModifier(modifier)).await?;

        let create_item_pkt = builder::message::create_individual_item(area_client, item_id, &weapon)?;

        let neighbors = client_location.get_client_neighbors(id).map_err(|err| -> ClientLocationError { err.into() })?;
        Ok(Box::new(neighbors.into_iter()
                    .map(move |c| {
                        (c.client, SendShipPacket::Message(Message::new(GameMessage::CreateItem(create_item_pkt.clone()))))
                })))
    }
    else {
        Err(MessageError::InvalidTek(ClientItemId(tek_accept.item_id)).into())
    }
}