use std::convert::{TryFrom, Into};
use futures::stream::StreamExt;

use async_std::sync::Arc;

use libpso::packet::ship::*;
use libpso::packet::messages::*;
use crate::common::serverstate::ClientId;
use crate::common::leveltable::LEVEL_TABLE;
use crate::entity::gateway::EntityGateway;
use crate::entity::character::SectionID;
use crate::entity::room::{NewRoomEntity, RoomEntityMode, RoomNote};
use crate::ship::drops::DropTable;
use crate::ship::ship::{SendShipPacket, Clients, ShipEvent};
use crate::ship::room::{Rooms, Episode, Difficulty, RoomState, RoomMode};
use crate::ship::map::Maps;
use crate::ship::location::{ClientLocation, RoomId, RoomLobby, GetAreaError};
use crate::ship::packet::builder;
use crate::ship::items::state::ItemState;

#[allow(clippy::too_many_arguments)]
pub async fn create_room<EG>(id: ClientId,
                             create_room: CreateRoom,
                             entity_gateway: &mut EG,
                             client_location: &mut ClientLocation,
                             clients: &Clients,
                             item_state: &mut ItemState,
                             rooms: &Rooms,
                             map_builder: Arc<Box<dyn Fn(RoomMode, ShipEvent) -> Maps + Send + Sync>>,
                             drop_table_builder: Arc<Box<dyn Fn(Episode, Difficulty, SectionID) -> DropTable + Send + Sync>>,
                             event: ShipEvent)
                             -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error>
where
    EG: EntityGateway + Clone + 'static,
{
    let level = clients.with(id, |client| Box::pin(async move {
        LEVEL_TABLE.get_level_from_exp(client.character.char_class, client.character.exp)
    })).await?;
    let difficulty = Difficulty::try_from(create_room.difficulty)?;
    match difficulty {
        Difficulty::Ultimate if level < 80 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 80 \nto create Ultimate rooms.".into())))])
        },
        Difficulty::VeryHard if level < 40 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 40 \nto create Very Hard rooms.".into())))])
        },
        Difficulty::Hard if level < 20 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 20 \nto create Hard rooms.".into())))])
        },
        _ => {},
    };

    let area = client_location.get_area(id).await?;
    let old_area_client = client_location.get_local_client(id).await?;
    let lobby_neighbors = client_location.get_client_neighbors(id).await?;

    let room_id = client_location.create_new_room(id).await?;
    let new_area_client = client_location.get_local_client(id).await?;

    let name = String::from_utf16_lossy(&create_room.name).trim_matches(char::from(0)).to_string();
    let mode = match (create_room.battle, create_room.challenge, create_room.single_player) {
        (1, 0, 0) => RoomEntityMode::Battle,
        (0, 1, 0) => RoomEntityMode::Challenge,
        (0, 0, 1) => RoomEntityMode::Single,
        _ => RoomEntityMode::Multi,
    };
    let episode = create_room.episode.try_into()?;
    let difficulty = create_room.difficulty.try_into()?;

    let room = clients.with(id, |client| {
        let mut item_state = item_state.clone();
        let mut entity_gateway = entity_gateway.clone();
        Box::pin(async move {
            item_state.add_character_to_room(room_id, &client.character, new_area_client).await;
            let room_entity = entity_gateway.create_room(NewRoomEntity {
                name: name.clone(),
                section_id: client.character.section_id,
                mode,
                episode,
                difficulty,
            }).await?;

            entity_gateway.add_room_note(room_entity.id, RoomNote::Create {
                character_id: client.character.id,
            }).await?;

            let mut room = RoomState::new(room_entity.id, mode, episode, difficulty,
                                          client.character.section_id, name, create_room.password, event,
                                          map_builder, drop_table_builder)?;
            room.bursting = true;
            Ok::<_, anyhow::Error>(room)
        })}).await??;

    let join_room = builder::room::join_room(id, clients, client_location, room_id, &room, event).await?;
    rooms.add(room_id, room).await?;

    let mut result = vec![(id, SendShipPacket::JoinRoom(join_room))];
    if let Ok(leader) = client_location.get_area_leader(area).await {
        let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(old_area_client.local_client.id(), leader.local_client.id()));
        result.extend(lobby_neighbors
                      .into_iter()
                      .map(move |c| {
                          (c.client, leave_lobby.clone())
                      }));
    }

    Ok(result)
}

pub async fn room_name_request(id: ClientId,
                               client_location: &ClientLocation,
                               rooms: &Rooms)
                               -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error> {
    let area = client_location.get_area(id).await?;
    match area {
        RoomLobby::Room(room) => {
            rooms.with(room, |room| Box::pin(async move {
                vec![(id, SendShipPacket::RoomNameResponse(RoomNameResponse {
                    name: room.name.clone()
                }))]
            })).await
        },
        RoomLobby::Lobby(_) => Err(GetAreaError::NotInRoom.into())
    }
}

#[allow(clippy::too_many_arguments)]
pub async fn join_room<EG>(id: ClientId,
                           pkt: MenuSelect,
                           entity_gateway: &mut EG,
                           client_location: &mut ClientLocation,
                           clients: &Clients,
                           item_state: &mut ItemState,
                           rooms: &Rooms,
                           event: ShipEvent)
                           -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error>
where
    EG: EntityGateway + Clone + 'static,
{
    let room_id = RoomId(pkt.item as usize);
    if !rooms.exists(room_id).await {
        return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("This room no longer exists!".into())))])
    }
    let level = clients.with(id, |client| Box::pin(async move {
        LEVEL_TABLE.get_level_from_exp(client.character.char_class, client.character.exp)
    })).await?;
    let (difficulty, bursting, room_entity_id) = rooms.with(room_id, |room| Box::pin(async move {
        (room.mode.difficulty(), room.bursting, room.room_id)
    })).await?;

    match difficulty {
        Difficulty::Ultimate if level < 80 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 80 \nto join Ultimate rooms.".into())))])
        },
        Difficulty::VeryHard if level < 40 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 40 \nto join Very Hard rooms.".into())))])
        },
        Difficulty::Hard if level < 20 => {
            return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("You must be at least level 20 \nto join Hard rooms.".into())))])
        },
        _ => {},
    }

    if bursting {
        return Ok(vec![(id, SendShipPacket::SmallDialog(SmallDialog::new("player is bursting\nplease wait".into())))])
    }

    let original_area = client_location.get_area(id).await?;
    let original_neighbors = client_location.get_client_neighbors(id).await?;
    let original_room_clients = client_location.get_clients_in_room(room_id).await?;
    client_location.add_client_to_room(id, room_id).await?;
    let area_client = client_location.get_local_client(id).await?;
    let room_leader = client_location.get_room_leader(room_id).await?;

    clients.with(id, |client| {
        let mut item_state = item_state.clone();
        let mut entity_gateway = entity_gateway.clone();
        Box::pin(async move {
            entity_gateway.add_room_note(room_entity_id, RoomNote::PlayerJoin {
                character_id: client.character.id,
            }).await?;
            item_state.add_character_to_room(room_id, &client.character, area_client).await;
            Ok::<_, anyhow::Error>(())
        })}).await??;

    let join_room = rooms.with(room_id, |room| {
        let clients = clients.clone();
        let client_location = client_location.clone();
        Box::pin(async move {
            builder::room::join_room(id, &clients, &client_location, room_id, room, event).await
        })}).await??;
    let add_to = clients.with(id, |client| {
        let item_state = item_state.clone();
        Box::pin(async move {
            builder::room::add_to_room(id, client, &area_client, &room_leader, &item_state, event).await
        })}).await??;

    rooms.with_mut(room_id, |room| Box::pin(async move {
        room.bursting = true;
    })).await?;

    Ok(vec![(id, SendShipPacket::JoinRoom(join_room))]
       .into_iter()
       .chain(original_room_clients.into_iter()
              .map(move |c| (c.client, SendShipPacket::AddToRoom(add_to.clone()))))
       .chain(futures::stream::iter(original_neighbors.into_iter())
              .filter_map(|c| {
                  let client_location = client_location.clone();
                  async move {
                      client_location.get_area_leader(original_area).await.ok().map(|leader| {
                          let leave_lobby = SendShipPacket::LeaveLobby(LeaveLobby::new(area_client.local_client.id(), leader.local_client.id()));
                          (c.client, leave_lobby)
                      })
                  }
              })
              .collect::<Vec<_>>()
              .await
       )
       .collect())
}

pub async fn done_bursting(id: ClientId,
                           client_location: &ClientLocation,
                           rooms: &Rooms)
                           -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error> {
    let room_id = client_location.get_room(id).await?;
    let rare_monster_list = rooms.with_mut(room_id, |room| Box::pin(async move {
        room.bursting = false;
        room.maps.get_rare_monster_list()
    })).await?;

    let area_client = client_location.get_local_client(id).await?;
    Ok(client_location.get_client_neighbors(id).await?.into_iter()
        .map(move |client| {
            (client.client, SendShipPacket::Message(Message::new(GameMessage::BurstDone(BurstDone {
                client: area_client.local_client.id(),
                target: 0
            }))))
        })
        .chain(std::iter::once_with(move || {
            (id, SendShipPacket::RareMonsterList(builder::room::build_rare_monster_list(rare_monster_list)))
        }))
        .collect())
}

pub async fn request_room_list(id: ClientId,
                               client_location: &ClientLocation,
                               rooms: &Rooms)
                               -> Vec<(ClientId, SendShipPacket)> {
    let active_room_list = rooms.stream()
        .enumerate()
        .filter_map(|(i, r)| async move {
            r.as_ref().map(|room| {
                let difficulty = room.get_difficulty_for_room_list();
                let name = libpso::utf8_to_utf16_array!(room.name, 16);
                let episode = room.get_episode_for_room_list();
                let flags = room.get_flags_for_room_list();
                async move {
                    RoomList {
                        menu_id: ROOM_MENU_ID,
                        item_id: i as u32,
                        difficulty,
                        players: client_location.get_clients_in_room(RoomId(i)).await.unwrap().len() as u8,
                        name,
                        episode,
                        flags,
                    }
                }})
        });
    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,
    };

    vec![(id, SendShipPacket::RoomListResponse(RoomListResponse {
        baseroom,
        rooms: futures::future::join_all(active_room_list.collect::<Vec<_>>().await).await
    }))]
}

pub async fn cool_62(id: ClientId,
                     cool_62: Like62ButCooler,
                     client_location: &ClientLocation)
                     -> Result<Vec<(ClientId, SendShipPacket)>, anyhow::Error> {
    let target = cool_62.flag as u8;
    let cool_62 = cool_62.clone();
    Ok(client_location
        .get_client_neighbors(id)
        .await?
        .into_iter()
        .filter(move |client| client.local_client.id() == target)
        .map(move |client| {
            (client.client, SendShipPacket::Like62ButCooler(cool_62.clone()))
        })
        .collect())
}