use libpso::packet::ship::*;
use libpso::packet::messages::*;
use crate::common::serverstate::ClientId;
use crate::common::leveltable::CharacterLevelTable;
use crate::ship::ship::{SendShipPacket, ShipError, Rooms, Clients};
use crate::ship::location::{ClientLocation, RoomId, RoomLobby, ClientLocationError};
use crate::ship::packet::builder;
use crate::ship::room;
use crate::ship::items::ItemManager;

pub fn create_room(id: ClientId,
                   create_room: &CreateRoom,
                   client_location: &mut ClientLocation,
                   clients: &mut Clients,
                   item_manager: &mut ItemManager,
                   rooms: &mut Rooms)
                   -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
    let area = client_location.get_area(id).unwrap();
    let area_client = client_location.get_local_client(id).unwrap();
    let lobby_neighbors = client_location.get_client_neighbors(id).unwrap();
    let room_id = client_location.create_new_room(id).unwrap();

    let client = clients.get_mut(&id).unwrap();//.ok_or(ShipError::ClientNotFound(id)).unwrap();
    let mut room = room::RoomState::from_create_room(create_room, client.character.section_id).unwrap();
    room.bursting = true;

    item_manager.add_character_to_room(room_id, &client.character, area_client);

    let join_room = builder::room::join_room(id, clients, client_location, room_id, &room)?;
    rooms[room_id.0] = Some(room);

    let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
        vec![(id, SendShipPacket::JoinRoom(join_room))].into_iter()
    );
    if let Ok(leader) = client_location.get_area_leader(area) {
        let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
        result = Box::new(result.chain(lobby_neighbors
                                       .into_iter()
                                       .map(move |c| {
                                           (c.client, leave_lobby.clone())
                                       })));
    }

    Ok(result)
}

pub fn room_name_request(id: ClientId,
                         client_location: &ClientLocation,
                         rooms: &Rooms)
                         -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let area = client_location.get_area(id).unwrap();
    match area {
        RoomLobby::Room(room) => Box::new(vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {name: rooms[room.0].as_ref().unwrap().name.clone()}))].into_iter()),
        RoomLobby::Lobby(_) => panic!()
    }
}

pub fn join_room(id: ClientId,
                 pkt: &MenuSelect,
                 client_location: &mut ClientLocation,
                 clients: &mut Clients,
                 item_manager: &mut ItemManager,
                 level_table: &CharacterLevelTable,
                 rooms: &mut Rooms)
                 -> Result<Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send>, ShipError> {
    let original_area = client_location.get_area(id).unwrap();
    let original_neighbors = client_location.get_client_neighbors(id).unwrap();
    let room = rooms.get(pkt.item as usize)
        .ok_or_else(|| ShipError::InvalidRoom(pkt.item))?.as_ref()
        .ok_or_else(|| ShipError::InvalidRoom(pkt.item))?;
    if room.bursting {
        return Ok(Box::new(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))].into_iter()))
    }
    let room_id = RoomId(pkt.item as usize);
    let original_room_clients = client_location.get_clients_in_room(room_id).map_err(|err| -> ClientLocationError { err.into() })?;
    client_location.add_client_to_room(id, room_id).unwrap(); // TODO: show room full error or whatever

    let client = clients.get(&id).ok_or(ShipError::ClientNotFound(id))?;
    let area_client = client_location.get_local_client(id).map_err(|err| -> ClientLocationError { err.into() })?;

    item_manager.add_character_to_room(room_id, &client.character, area_client);

    let leader = client_location.get_room_leader(room_id).map_err(|err| -> ClientLocationError { err.into() })?;
    let join_room = builder::room::join_room(id, clients, client_location, room_id, &room)?;
    let add_to = builder::room::add_to_room(id, &client, &area_client, &leader, item_manager, level_table, room_id)?;

    let room = rooms.get_mut(room_id.0).unwrap().as_mut().unwrap();
    room.bursting = true;

    let mut result: Box<dyn Iterator<Item=(ClientId, SendShipPacket)> + Send> = Box::new(
        vec![(id, SendShipPacket::JoinRoom(join_room))]
            .into_iter()
            .chain(original_room_clients.clone().into_iter()
                   .map(move |c| (c.client, SendShipPacket::AddToRoom(add_to.clone())))
            ));

    if let Ok(leader) = client_location.get_area_leader(original_area) {
        let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
        result = Box::new(result.chain(original_neighbors.into_iter()
                                       .map(move |c| (c.client, leave_lobby.clone()))))
    }

    Ok(result)
}

pub fn done_bursting(id: ClientId,
                     client_location: &ClientLocation,
                     rooms: &mut Rooms)
                     -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let area = client_location.get_area(id).unwrap();
    if let RoomLobby::Room(room_id) = area {
        rooms.get_mut(room_id.0).unwrap().as_mut().map(|room| {
            room.bursting = false;
        });
    }
    let area_client = client_location.get_local_client(id).unwrap(); // TODO: unwrap
    Box::new(client_location.get_client_neighbors(id).unwrap().into_iter() // TODO: unwrap
             .map(move |client| {
                 vec![
                     (client.client, SendShipPacket::Message(Message::new(GameMessage::BurstDone(BurstDone {
                         client: area_client.local_client.id(),
                         target: 0
                     })))),
                 ]
             }).flatten())
}

pub fn request_room_list(id: ClientId,
                         client_location: &ClientLocation,
                         rooms: &Rooms)
                         -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let active_room_list = rooms.iter()
        .enumerate()
        .filter_map(|(i, r)| {
            r.as_ref().map(|room| {
                RoomList {
                    menu_id: ROOM_MENU_ID,
                    item_id: i as u32,
                    difficulty: room.get_difficulty_for_room_list(),
                    players: client_location.get_clients_in_room(RoomId(i)).unwrap().len() as u8,
                    name: libpso::utf8_to_utf16_array!(room.name, 16),
                    episode: room.get_episode_for_room_list(),
                    flags: room.get_flags_for_room_list(),
                }
            })
        });
    let baseroom: RoomList = RoomList {
        menu_id: ROOM_MENU_ID,
        item_id: ROOM_MENU_ID,
        difficulty: 0x00,
        players: 0x00,
        name: libpso::utf8_to_utf16_array!("Room list menu", 16),
        episode: 0,
        flags: 0,
    };

    Box::new(vec![(id, SendShipPacket::RoomListResponse(RoomListResponse {
        baseroom,
        rooms: active_room_list.collect()
    }))].into_iter())
}

pub fn cool_62(id: ClientId,
               cool_62: &Like62ButCooler,
               client_location: &ClientLocation)
               -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
    let target = cool_62.flag as u8;
    let cool_62 = cool_62.clone();
    Box::new(client_location.get_client_neighbors(id).unwrap().into_iter()
             .filter(move |client| client.local_client.id() == target)
             .map(move |client| {
                 (client.client, SendShipPacket::Like62ButCooler(cool_62.clone()))
             }))
}