use std::collections::HashMap;

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::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::{UserAccount, UserSettings, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
use crate::entity::character::Character;
use crate::entity::item::ItemLocation;
use crate::login::login::get_login_status;
use crate::ship::location::ClientLocation;
use crate::ship::character::{CharacterBuilder, FullCharacterBuilder};

pub const SHIP_PORT: u16 = 23423;

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

#[derive(Debug)]
pub enum RecvShipPacket {
    Login(Login),
    MenuSelect(MenuSelect),
    CharData(CharData),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
}

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)?)),
            _ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
        }
    }
}

#[derive(Debug)]
pub enum SendShipPacket {
    ShipWelcome(ShipWelcome),
    LoginResponse(LoginResponse),
    ShipBlockList(ShipBlockList),
    FullCharacter(FullCharacter),
    CharDataRequest(CharDataRequest),
    JoinLobby(JoinLobby),
    AddToLobby(AddToLobby),
    Message(Message),
    DirectMessage(DirectMessage),
    PlayerChat(PlayerChat),
}

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(),
        }
    }
}


struct ClientState {
    user: UserAccount,
    settings: UserSettings,
    character: Character,
    session: Session,
    block: u32,
    room_client_id: u32,
}

impl ClientState {
    fn new(user: UserAccount, settings: UserSettings, character: Character, session: Session) -> ClientState {
        ClientState {
            user: user,
            settings: settings,
            character: character,
            session: session,
            block: 1,
            room_client_id: 0,
        }
    }
}


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

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(),
        }
    }

    fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendShipPacket>, ShipError> {
        Ok(match get_login_status(&self.entity_gateway, pkt) {
            Ok(user) => {
                let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
                response.guildcard = user.guildcard.map_or(24, |gc| gc) as u32;
                response.team_id = user.team_id.map_or(31, |ti| ti) as u32;
                let characters = self.entity_gateway.get_characters_by_user(&user);
                let character = characters
                    .get(pkt.session.character_slot as usize)
                    .ok_or(ShipError::InvalidSlot(id, pkt.session.character_slot as u32))?
                    .ok_or(ShipError::NoCharacterInSlot(id, pkt.session.character_slot as u32))?;
                let settings = self.entity_gateway.get_user_settings_by_user(&user)
                    .ok_or(ShipError::ClientNotFound(id))?;

                self.clients.insert(id, ClientState::new(user, settings, character, pkt.session));
                vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(&self.name, 3))]
            },
            Err(err) => {
                vec![SendShipPacket::LoginResponse(LoginResponse::by_status(err, Session::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(character::Class::from(client.character.character.ch_class), client.character.character.exp);

        let items = self.entity_gateway.get_items_by_character(&client.character);
        let (inventory, inv_len) = items
            .iter()
            .take(30)
            .fold(([character::InventoryItem::default(); 30], 0), |(mut inv, len), item| {
                let index = {
                    if let ItemLocation::Inventory{index, .. } = item.location {
                        index
                    }
                    else {
                        panic!("inventory item that isnt in inventory???");
                    }
                };
                let bytes = item.item.as_bytes();
                inv[index].data1.copy_from_slice(&bytes[0..12]);
                inv[index].item_id = item.id;
                (inv, len+1)
            });
        let fc = FullCharacterBuilder::new()
            .character(&CharacterBuilder::new()
                       .character(&client.character.character)
                       .stats(&stats)
                       .level(level - 1)
                       .build())
            .inventory(&inventory, inv_len)
            .key_config(&client.settings.settings.key_config)
            .joystick_config(&client.settings.settings.joystick_config)
            //.team_config(&joystick_config)
            .build();

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

    fn send_player_to_lobby(&mut self, id: ClientId, _pkt: &CharData) -> Result<Vec<(ClientId, SendShipPacket)>, ShipError> {
        self.client_location.add_to_lobby(id, 0).unwrap();

        let lobby = self.client_location.get_area_by_user(id);
        let clients = lobby.clients();
        println!("clients in lobby: {:?}", clients);
        let playerinfo = clients.iter()
            .map(|room_client| {
                let client = self.clients.get(&room_client.client_id).ok_or(ShipError::ClientNotFound(id)).unwrap();
                let (level, stats) = self.level_table.get_stats_from_exp(character::Class::from(client.character.character.ch_class), client.character.character.exp);
                let c = CharacterBuilder::new()
                    .character(&client.character.character)
                    .stats(&stats)
                    .level(level - 1)
                    .build();
                PlayerInfo {
                    header: PlayerHeader {
                        tag: 0x100,
                        guildcard: client.user.id,
                        _unknown1: [0; 5],
                        client_id: room_client.index as u32,
                        name: c.name,
                        _unknown2: 2,
                    },
                    inventory: character::Inventory {
                        item_count: 0,
                        hp_mats_used: 0,
                        tp_mats_used: 0,
                        language: 0,
                        items: [character::InventoryItem::default(); 30],
                    },
                    character: c,
                }
            });
        let client_id = clients.iter()
            .fold(0, |acc, k| {
                if k.client_id == id {
                    k.index
                }
                else {
                    acc
                }
            });

        let join_lobby = JoinLobby {
            client: client_id as u8,
            leader: lobby.leader().index as u8,
            one: 1,
            lobby: lobby.id() as u8,
            block: 1,
            event: 0,
            padding: 0,
            playerinfo: playerinfo.collect(),
        };

        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        let (level, stats) = self.level_table.get_stats_from_exp(character::Class::from(client.character.character.ch_class), client.character.character.exp);
        let c = CharacterBuilder::new()
            .character(&client.character.character)
            .stats(&stats)
            .level(level - 1)
            .build();
        let addto = AddToLobby {
            flag: 1,
            client: client_id as u8,
            leader: lobby.leader().index as u8,
            one: 1,
            lobby: lobby.id() as u8,
            block: 1,
            event: 0,
            padding: 0,
            playerinfo: PlayerInfo {
                header: PlayerHeader {
                    tag: 0x100,
                    guildcard: client.user.id,
                    _unknown1: [0; 5],
                    client_id: client_id as u32,
                    name: c.name,
                    _unknown2: 2,
                },
                inventory: character::Inventory {
                    item_count: 0,
                    hp_mats_used: 0,
                    tp_mats_used: 0,
                    language: 0,
                    items: [character::InventoryItem::default(); 30],
                },
                character: c,
            },
        };

        let mut v = Vec::new();
        v.push((id, SendShipPacket::JoinLobby(join_lobby)));
        for client in clients {
            if client.client_id != id {
                v.push((client.client_id, SendShipPacket::AddToLobby(addto.clone()))
            )}
        }

        Ok(v)
    }

    fn message(&mut self, id: ClientId, msg: &Message) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)>> {
        let cmsg = msg.clone();
        Box::new(self.client_location.get_area_by_user(id).clients().iter()
                 .filter(|client| client.client_id != id)
                 .map(move |client| {
                     (client.client_id, SendShipPacket::Message(cmsg.clone()))
                 }).collect::<Vec<_>>().into_iter())
    }

    fn direct_message(&mut self, id: ClientId, msg: &DirectMessage) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)>> {
        let cmsg = msg.clone();
        Box::new(self.client_location.get_area_by_user(id).clients().iter()
                 .filter(|client| client.index == cmsg.flag as usize)
                 .map(|client| {
                     (client.client_id, SendShipPacket::DirectMessage(cmsg.clone()))
                 }).collect::<Vec<_>>().into_iter())
    }

    fn player_chat(&mut self, id: ClientId, msg: &PlayerChat) -> Box<dyn Iterator<Item = (ClientId, SendShipPacket)>> {
        let client = self.clients.get_mut(&id).ok_or(ShipError::ClientNotFound(id)).unwrap();
        let mut cmsg = PlayerChat::new(0x00010000, client.user.guildcard.unwrap(), msg.message.clone());
        let mut mlen = (cmsg.message.len() * 2) + 0x12;
        while mlen & 0x07 != 0 {
            cmsg.message.push('\0');
            mlen += 1;
        }
        
        Box::new(self.client_location.get_area_by_user(id).clients().iter()
                .map(move |client| {
                    (client.client_id, SendShipPacket::PlayerChat(cmsg.clone()))
                }).collect::<Vec<_>>().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)>>, ShipError> {
        Ok(match pkt {
            RecvShipPacket::Login(login) => {
                Box::new(self.validate_login(id, login)?.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))),
                    _ => unreachable!(),
                }
            },
            RecvShipPacket::CharData(chardata) => {
                Box::new(self.send_player_to_lobby(id, chardata)?.into_iter())
            },
            RecvShipPacket::Message(msg) => {
                self.message(id, msg)
            },
            RecvShipPacket::DirectMessage(msg) => {
                self.direct_message(id, msg)
            },

            RecvShipPacket::PlayerChat(msg) => {
                self.player_chat(id, msg)
            },
        })
    }
}