use libpso::packet::ship::*;
use crate::common::serverstate::ClientId;
use crate::common::leveltable::CharacterLevelTable;
use crate::ship::ship::{SendShipPacket, ShipError, Clients, Rooms};
use crate::ship::character::{FullCharacterBytesBuilder};
use crate::ship::location::{ClientLocation, LobbyId, RoomLobby, ClientLocationError};
//use crate::ship::items::;
use crate::ship::packet;
use crate::ship::items::ItemManager;
use crate::entity::gateway::EntityGateway;

// this function needs a better home
pub fn block_selected(id: ClientId,
                      pkt: &MenuSelect,
                      clients: &mut Clients,
                      item_manager: &ItemManager,
                      level_table: &CharacterLevelTable)
                      -> Result<Vec<SendShipPacket>, ShipError> {
    let client = clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
    client.block = pkt.item as u32;

    let (level, stats) = level_table.get_stats_from_exp(client.character.char_class, client.character.exp);

    let inventory = item_manager.get_character_inventory(&client.character).unwrap();
    let bank = item_manager.get_character_bank(&client.character).unwrap();

    let fc = FullCharacterBytesBuilder::new()
        .character(&client.character)
        .stats(&stats)
        .level(level)
        .inventory(&inventory)
        .bank(&bank)
        .key_config(&client.settings.settings.key_config)
        .joystick_config(&client.settings.settings.joystick_config)
        .symbol_chat(&client.settings.settings.symbol_chats)
        .tech_menu(&client.character.tech_menu.as_bytes())
        .option_flags(client.character.option_flags)
        .build();

    Ok(vec![
        SendShipPacket::FullCharacter(FullCharacter {
            character: fc,
        }),
        SendShipPacket::CharDataRequest(CharDataRequest {}),
        SendShipPacket::LobbyList(LobbyList::new()),
    ])
}

pub fn send_player_to_lobby(id: ClientId,
                            _pkt: &CharData,
                            client_location: &mut ClientLocation,
                            clients: &Clients,
                            item_manager: &ItemManager,
                            level_table: &CharacterLevelTable)
                            -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
    let lobby = client_location.add_client_to_next_available_lobby(id, LobbyId(0)).map_err(|_| ShipError::TooManyClients)?;
    let join_lobby = packet::builder::lobby::join_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
    let addto = packet::builder::lobby::add_to_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
    let neighbors = client_location.get_client_neighbors(id).unwrap();
    Ok(vec![(id, SendShipPacket::JoinLobby(join_lobby))]
       .into_iter()
       .chain(neighbors.into_iter()
              .map(|c| (c.client, SendShipPacket::AddToLobby(addto.clone())))).collect())
}

pub async fn change_lobby<EG: EntityGateway>(id: ClientId,
                                             requested_lobby: u32,
                                             client_location: &mut ClientLocation,
                                             clients: &Clients,
                                             item_manager: &mut ItemManager,
                                             level_table: &CharacterLevelTable,
                                             ship_rooms: &mut Rooms,
                                             entity_gateway: &mut EG)
                                             -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
    let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
    let prev_area = client_location.get_area(id).map_err(|err| -> ClientLocationError {err.into()})?;
    match prev_area {
        RoomLobby::Lobby(old_lobby) => {
            if old_lobby.0 == requested_lobby as usize {
                return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You are already in this Lobby!".into())))])
            }
        },
        RoomLobby::Room(old_room) => {
            if client_location.get_client_neighbors(id).map_err(|err| -> ClientLocationError {err.into()})?.len() == 0 {
                ship_rooms[old_room.0] = None;
            }
            item_manager.remove_character_from_room(&client.character);
        },
    }
    let leave_lobby = packet::builder::lobby::remove_from_lobby(id, client_location)?;
    let old_neighbors = client_location.get_client_neighbors(id).unwrap();
    let mut lobby = LobbyId(requested_lobby as usize);
    if let Err(_) = client_location.add_client_to_lobby(id, lobby) {
        match prev_area {
            RoomLobby::Lobby(_lobby) => {
                let dialog = SmallDialog::new(String::from("Lobby is full."));
                return Ok(vec![(id, SendShipPacket::SmallDialog(dialog))])
            }
            RoomLobby::Room(_room) => {
                lobby = client_location.add_client_to_next_available_lobby(id, lobby).map_err(|_| ShipError::TooManyClients)?;
            }
        }
    }
    item_manager.load_character(entity_gateway, &client.character).await;
    let join_lobby = packet::builder::lobby::join_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
    let addto = packet::builder::lobby::add_to_lobby(id, lobby, client_location, clients, item_manager, level_table)?;
    let neighbors = client_location.get_client_neighbors(id).unwrap();
    Ok(vec![(id, SendShipPacket::JoinLobby(join_lobby))]
        .into_iter()
        .chain(neighbors.into_iter()
            .map(|c| (c.client, SendShipPacket::AddToLobby(addto.clone()))))
        .chain(old_neighbors.into_iter()
            .map(|c| (c.client, SendShipPacket::LeaveLobby(leave_lobby.clone()))))
        .collect())
}