use std::collections::HashMap;
use log::warn;

use rand::Rng;

use libpso::packet::ship::*;
use libpso::packet::login::{Login, LoginResponse, AccountStatus, Session};
use libpso::packet::messages::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::bb::PSOBBCipher;
use libpso::character::character;
use libpso::packet::ship::{BLOCK_MENU_ID, ROOM_MENU_ID};
use libpso::{utf8_to_array, utf8_to_utf16_array};

use crate::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
use crate::common::serverstate::{SendServerPacket, RecvServerPacket, ServerState, OnConnect, ClientId};
use crate::common::leveltable::CharacterLevelTable;

use crate::entity::gateway::EntityGateway;
use crate::entity::account::{UserAccountEntity, UserSettingsEntity, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
use crate::entity::character::CharacterEntity;
use crate::entity::item::{ItemLocation, ItemEntity};
use crate::ship::location::{ClientLocation, LobbyId, RoomId, RoomLobby, MAX_ROOMS};
use crate::ship::character::{CharacterBytesBuilder, FullCharacterBytesBuilder};
use crate::ship::items;
use crate::ship::room;
use crate::ship::packet::handler;

pub const SHIP_PORT: u16 = 23423;
pub type Rooms = [Option<room::RoomState>; MAX_ROOMS];

#[derive(Debug)]
pub enum ShipError {
    ClientNotFound(ClientId),
    NoCharacterInSlot(ClientId, u32),
    InvalidSlot(ClientId, u32),
    TooManyClients,
    ClientError(String),
    InvalidRoom(u32),
}

#[derive(Debug)]
pub enum RecvShipPacket {
    Login(Login),
    MenuSelect(MenuSelect),
    CharData(CharData),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
    CreateRoom(CreateRoom),
    RoomNameRequest(RoomNameRequest),
    UpdateConfig(UpdateConfig),
    ViewInfoboardRequest(ViewInfoboardRequest),
    WriteInfoboard(WriteInfoboard),
    RoomListRequest(RoomListRequest),
    Like62ButCooler(Like62ButCooler),
    ClientCharacterData(ClientCharacterData),
    DoneBursting(DoneBursting),
}

impl RecvServerPacket for RecvShipPacket {
    fn from_bytes(data: &[u8]) -> Result<RecvShipPacket, PacketParseError> {
        match u16::from_le_bytes([data[2], data[3]]) {
            0x93 => Ok(RecvShipPacket::Login(Login::from_bytes(data)?)),
            0x10 => Ok(RecvShipPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
            0x61 => Ok(RecvShipPacket::CharData(CharData::from_bytes(data)?)),
            0x60 => Ok(RecvShipPacket::Message(Message::from_bytes(data)?)),
            0x62 => Ok(RecvShipPacket::DirectMessage(DirectMessage::from_bytes(data)?)),
            0x06 => Ok(RecvShipPacket::PlayerChat(PlayerChat::from_bytes(data)?)),
            0xC1 => Ok(RecvShipPacket::CreateRoom(CreateRoom::from_bytes(data)?)),
            0x8A => Ok(RecvShipPacket::RoomNameRequest(RoomNameRequest::from_bytes(data)?)),
            0x7ED => Ok(RecvShipPacket::UpdateConfig(UpdateConfig::from_bytes(data)?)),
            0xD8 => Ok(RecvShipPacket::ViewInfoboardRequest(ViewInfoboardRequest::from_bytes(data)?)),
            0xD9 => Ok(RecvShipPacket::WriteInfoboard(WriteInfoboard::from_bytes(data)?)),
            0x08 => Ok(RecvShipPacket::RoomListRequest(RoomListRequest::from_bytes(data)?)),
            0x6D => Ok(RecvShipPacket::Like62ButCooler(Like62ButCooler::from_bytes(data)?)),
            0x98 => Ok(RecvShipPacket::ClientCharacterData(ClientCharacterData::from_bytes(data)?)),
            0x6F => Ok(RecvShipPacket::DoneBursting(DoneBursting::from_bytes(data)?)),
            _ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
        }
    }
}

#[derive(Debug, Clone)]
pub enum SendShipPacket {
    ShipWelcome(ShipWelcome),
    LoginResponse(LoginResponse),
    ShipBlockList(ShipBlockList),
    FullCharacter(FullCharacter),
    CharDataRequest(CharDataRequest),
    JoinLobby(JoinLobby),
    AddToLobby(AddToLobby),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
    SmallDialog(SmallDialog),
    JoinRoom(JoinRoom),
    AddToRoom(AddToRoom),
    LeaveLobby(LeaveLobby),
    LeaveRoom(LeaveRoom),
    RoomNameResponse(RoomNameResponse),
    ViewInfoboardResponse(ViewInfoboardResponse),
    RoomListResponse(RoomListResponse),
    Like62ButCooler(Like62ButCooler),
    BurstDone72(BurstDone72),
    DoneBursting(DoneBursting),
}

impl SendServerPacket for SendShipPacket {
    fn as_bytes(&self) -> Vec<u8> {
        match self {
            SendShipPacket::ShipWelcome(pkt) => pkt.as_bytes(),
            SendShipPacket::LoginResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::ShipBlockList(pkt) => pkt.as_bytes(),
            SendShipPacket::FullCharacter(pkt) => pkt.as_bytes(),
            SendShipPacket::CharDataRequest(pkt) => pkt.as_bytes(),
            SendShipPacket::JoinLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::AddToLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::Message(pkt) => pkt.as_bytes(),
            SendShipPacket::DirectMessage(pkt) => pkt.as_bytes(),
            SendShipPacket::PlayerChat(pkt) => pkt.as_bytes(),
            SendShipPacket::SmallDialog(pkt) => pkt.as_bytes(),
            SendShipPacket::JoinRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::AddToRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::LeaveLobby(pkt) => pkt.as_bytes(),
            SendShipPacket::LeaveRoom(pkt) => pkt.as_bytes(),
            SendShipPacket::RoomNameResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::ViewInfoboardResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::RoomListResponse(pkt) => pkt.as_bytes(),
            SendShipPacket::Like62ButCooler(pkt) => pkt.as_bytes(),
            SendShipPacket::BurstDone72(pkt) => pkt.as_bytes(),
            SendShipPacket::DoneBursting(pkt) => pkt.as_bytes(),
        }
    }
}

pub struct ClientState {
    pub user: UserAccountEntity,
    settings: UserSettingsEntity,
    pub character: CharacterEntity,
    session: Session,
    //guildcard: GuildCard,
    inventory: items::ActiveInventory,
    //bank: Bank,
    block: u32,
}

impl ClientState {
    pub fn new(user: UserAccountEntity, settings: UserSettingsEntity, character: CharacterEntity, inventory: items::ActiveInventory, /*bank: Bank,*/ session: Session) -> ClientState {
        ClientState {
            user: user,
            settings: settings,
            character: character,
            session: session,
            inventory: inventory,
            //bank: bank,
            block: 1,
        }
    }
}


pub struct ShipServerState<EG: EntityGateway> {
    entity_gateway: EG,
    clients: HashMap<ClientId, ClientState>,
    client_location: ClientLocation,
    level_table: CharacterLevelTable,
    name: String,
    rooms: Rooms,
    item_database: items::ActiveItemDatabase,
}

impl<EG: EntityGateway> ShipServerState<EG> {
    pub fn new(entity_gateway: EG) -> ShipServerState<EG> {
        ShipServerState {
            entity_gateway: entity_gateway,
            clients: HashMap::new(),
            client_location: ClientLocation::new(),
            level_table: CharacterLevelTable::new(),
            name: "Sona-Nyl".into(),
            rooms: [None; MAX_ROOMS],
            item_database: items::ActiveItemDatabase::new(),
        }
    }

    fn block_selected(&mut self, id: ClientId, pkt: &MenuSelect) -> Result<Vec<SendShipPacket>, ShipError> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
        client.block = pkt.item as u32;

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

        let fc = FullCharacterBytesBuilder::new()
            .character(&client.character)
            .stats(&stats)
            .level(level)
            .inventory(&client.inventory)
            .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())
            .build();

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




    fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        match &msg.msg {
            GameMessage::RequestExp(killmonster) => {
                match self.client_location.get_area(id).unwrap() {
                    RoomLobby::Room(room) => {
                        let r  = self.rooms[room.0].as_ref().unwrap();
                        warn!("killed a {:?}", r.maps.enemy_by_id(killmonster.enemy_id as usize).monster);
                    },
                    _ => {}
                }
            },
            _ => {},
        }

        let cmsg = msg.clone();
        Box::new(self.client_location.get_client_neighbors(id).unwrap().into_iter()
                 .map(move |client| {
                     (client.client, SendShipPacket::Message(cmsg.clone()))
                 }))
    }

    /*fn generate_item_drop(&mut self, id: ClientId, monster: MonsterType) -> Option<ActiveItem> {
        let room = self.rooms[self.client_location.get_area_by_user(id).index];
        let item_drop = room.drop_table.get_drop()
    }*/

    fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let cmsg = msg.clone();
        let client = self.clients.get_mut(&id).unwrap();
        match &cmsg.msg {
            GameMessage::GuildcardSend(guildcard_send) => {
                let out_msg = DirectMessage{
                    flag: cmsg.flag,
                    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(),
                    }),
                };
                let msg_flag = cmsg.flag as u8;
                Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                    .filter(move |client| client.local_client.id() == msg_flag)
                    .map(move |client| {
                        (client.client, SendShipPacket::DirectMessage(out_msg.clone()))
                    }))
            },
            /*GameMessage::RequestItem(req_item) => {
                let item = self.generate_item_drop(id);
                Box::new(vec![(id, SendShipPacket::Message(Message::new(GameMessage::ItemDrop(ItemDrop {
                    client: req_item.client,
                    target: req_item.target,
                    area: req_item.area,
                    variety: 0,
                    unknown: 0,
                    x: req_item.x,
                    z: req_item.z,
                    unknown2: 0,
                    item_bytes: item[0..12].try_into().unwrap(),
                    item_id: 0,
                    item_bytes2: item[12..16].try_into().unwrap(),
                    unknown3: 0,
                }))))].into_iter())
            },*/
            _ => {
                let msg_flag = cmsg.flag as u8;
                Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                    .filter(move |client| client.local_client.id() == msg_flag)
                    .map(move |client| {
                        (client.client, SendShipPacket::DirectMessage(cmsg.clone()))
                    }))
            },
        }
    }

    fn player_chat(&mut self, id: ClientId, msg: &PlayerChat) -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id))?;
        let cmsg = PlayerChat::new(client.user.id.0, msg.message.clone());

        Ok(Box::new(self.client_location.get_all_clients_by_client(id).unwrap().into_iter()
                .map(move |client| {
                    (client.client, SendShipPacket::PlayerChat(cmsg.clone()))
                })))
    }

    fn update_config(&mut self, id: ClientId, update_config: &UpdateConfig) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        client.character.config.update(update_config);
        self.entity_gateway.save_character(&client.character);
        Box::new(None.into_iter())
    }

    fn request_infoboard(&mut self, id: ClientId, request_infoboard: &ViewInfoboardRequest) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let clients = self.client_location.get_client_neighbors(id).unwrap();
        let r = clients.iter()
            .filter_map(|c| {
                self.clients.get(&c.client)
            })
            .map(|client| {
                InfoboardResponse {
                    name: libpso::utf8_to_utf16_array!(client.character.name, 16),
                    message: client.character.info_board.as_bytes(),
                }
            }).collect();
        Box::new(vec![(id, SendShipPacket::ViewInfoboardResponse(ViewInfoboardResponse {response: r}))].into_iter())
    }

    fn write_infoboard(&mut self, id: ClientId, new_infoboard: &WriteInfoboard) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        client.character.info_board.update_infoboard(new_infoboard);
        self.entity_gateway.save_character(&client.character);
        Box::new(None.into_iter())
    }

}

impl<EG: EntityGateway> ServerState for ShipServerState<EG> {
    type SendPacket = SendShipPacket;
    type RecvPacket = RecvShipPacket;
    type PacketError = ShipError;

    fn on_connect(&mut self, id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
        let mut rng = rand::thread_rng();

        let mut server_key = [0u8; 48];
        let mut client_key = [0u8; 48];
        rng.fill(&mut server_key[..]);
        rng.fill(&mut client_key[..]);

        vec![OnConnect::Packet(SendShipPacket::ShipWelcome(ShipWelcome::new(server_key, client_key))),
             OnConnect::Cipher((Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, client_key)),
                                Box::new(PSOBBCipher::new(ELSEWHERE_PARRAY, ELSEWHERE_PRIVATE_KEY, server_key))))
        ]
    }

    fn handle(&mut self, id: ClientId, pkt: &RecvShipPacket)
              -> Result<Box<dyn Iterator<Item = (ClientId, SendShipPacket)> + Send>, ShipError> {
        Ok(match pkt {
            RecvShipPacket::Login(login) => {
                Box::new(handler::auth::validate_login(id, login, &mut self.entity_gateway, &mut self.clients, &mut self.item_database, &self.name)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvShipPacket::MenuSelect(menuselect) => {
                match menuselect.menu {
                    BLOCK_MENU_ID => Box::new(self.block_selected(id, menuselect)?.into_iter().map(move |pkt| (id, pkt))),
                    ROOM_MENU_ID => Box::new(handler::room::join_room(id, menuselect, &mut self.client_location, &mut self.clients, &self.level_table, &mut self.rooms)?.into_iter()),
                    _ => unreachable!(),
                }
            },
            RecvShipPacket::CharData(chardata) => {
                Box::new(handler::lobby::send_player_to_lobby(id, chardata, &mut self.client_location, &self.clients, &self.level_table)?.into_iter())
            },
            RecvShipPacket::Message(msg) => {
                self.message(id, msg)
            },
            RecvShipPacket::DirectMessage(msg) => {
                self.direct_message(id, msg)
            },

            RecvShipPacket::PlayerChat(msg) => {
                Box::new(self.player_chat(id, msg)?.into_iter())
            },
            RecvShipPacket::CreateRoom(create_room) => {
                handler::room::create_room(id, create_room, &mut self.client_location, &mut self.clients, &mut self.rooms)
            },
            RecvShipPacket::RoomNameRequest(_req) => {
                handler::room::room_name_request(id, &self.client_location, &self.rooms)
            },
            RecvShipPacket::UpdateConfig(pkt) => {
                self.update_config(id, pkt)
            },

            RecvShipPacket::ViewInfoboardRequest(pkt) => {
                self.request_infoboard(id, pkt)
            },
            RecvShipPacket::WriteInfoboard(pkt) => {
                self.write_infoboard(id, pkt)
            },
            RecvShipPacket::RoomListRequest(_req) => {
                handler::room::request_room_list(id, &self.client_location, &self.rooms)
            },
            RecvShipPacket::Like62ButCooler(cool62) => {
                handler::room::cool_62(id, cool62, &self.client_location)
            },
            RecvShipPacket::ClientCharacterData(_) => {
                // TOOD: validate this in some way?
                Box::new(None.into_iter())
            },
            RecvShipPacket::DoneBursting(_) => {
                handler::room::done_bursting(id, &self.client_location, &mut self.rooms)
            }
        })
    }

    fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendShipPacket)> {
        let client = self.client_location.get_local_client(id).unwrap();
        let neighbors = self.client_location.get_client_neighbors(id).unwrap();

        let pkt = match self.client_location.get_area(id).unwrap() {
            RoomLobby::Room(room) => {
                let leader = self.client_location.get_room_leader(room).unwrap();
                SendShipPacket::LeaveRoom(LeaveRoom::new(client.local_client.id(), leader.local_client.id()))
            },
            RoomLobby::Lobby(lobby) => {
                let leader = self.client_location.get_lobby_leader(lobby).unwrap();
                SendShipPacket::LeaveLobby(LeaveLobby::new(client.local_client.id(), leader.local_client.id()))
            }
        };

        self.client_location.remove_client_from_area(id);

        neighbors.into_iter().map(|n| {
            (n.client, pkt.clone())
        }).collect()
    }
}