use super::{

    anteroom::HwAnteroomClient,

    client::HwClient,

    indexslab::IndexSlab,

    room::HwRoom,

    types::{CheckerId, ClientId, RoomId, Voting},

};

use crate::utils;

use hedgewars_network_protocol::types::{GameCfg, ServerVar, TeamInfo, Vote, VoteType};

use crate::server::replaystorage::ReplayStorage;

use bitflags::*;

use log::*;

use rand::{self, seq::SliceRandom, thread_rng, Rng};

use slab::Slab;

use std::{borrow::BorrowMut, cmp::min, collections::HashSet, iter, mem::replace};

#[derive(Debug)]

pub enum CreateRoomError {

    InvalidName,

    AlreadyExists,

}

#[derive(Debug)]

pub enum JoinRoomError {

    DoesntExist,

    WrongProtocol,

    WrongPassword,

    Full,

    Restricted,

    RegistrationRequired,

}

#[derive(Debug)]

pub enum LeaveRoomResult {

    RoomRemoved,

    RoomRemains {

        is_empty: bool,

        was_master: bool,

        was_in_game: bool,

        new_master: Option<ClientId>,

        removed_teams: Vec<String>,

    },

}

#[derive(Debug)]

pub struct ChangeMasterResult {

    pub old_master_id: Option<ClientId>,

    pub new_master_id: ClientId,

}

#[derive(Debug)]

pub enum ChangeMasterError {

    NoAccess,

    AlreadyMaster,

    NoClient,

    ClientNotInRoom,

}

#[derive(Debug)]

pub enum AddTeamError {

    TooManyTeams,

    TooManyHedgehogs,

    TeamAlreadyExists,

    Restricted,

}

#[derive(Debug)]

pub enum RemoveTeamError {

    NoTeam,

    TeamNotOwned,

}

#[derive(Debug)]

pub enum ModifyTeamError {

    NoTeam,

    NotMaster,

}

#[derive(Debug)]

pub enum SetTeamCountError {

    InvalidNumber,

    NotMaster,

}

#[derive(Debug)]

pub enum SetHedgehogsError {

    NoTeam,

    InvalidNumber(u8),

    NotMaster,

}

#[derive(Debug)]

pub enum SetConfigError {

    NotMaster,

    RoomFixed,

}

#[derive(Debug)]

pub enum ModifyRoomNameError {

    AccessDenied,

    InvalidName,

    DuplicateName,

}

#[derive(Debug)]

pub enum StartVoteError {

    VotingInProgress,

}

#[derive(Debug)]

pub enum VoteEffect {

    Kicked(ClientId, LeaveRoomResult),

    Map(String),

    Pause,

    NewSeed(GameCfg),

    HedgehogsPerTeam(u8, Vec<String>),

}

#[derive(Debug)]

pub enum VoteResult {

    Submitted,

    Succeeded(VoteEffect),

    Failed,

}

#[derive(Debug)]

pub enum VoteError {

    NoVoting,

    AlreadyVoted,

}

#[derive(Debug)]

pub enum StartGameError {

    NotEnoughClans,

    NotReady,

    AlreadyInGame,

}

#[derive(Debug)]

pub struct EndGameResult {

    pub left_teams: Vec<String>,

    pub unreadied_nicks: Vec<String>,

}

#[derive(Debug)]

pub struct UninitializedError();

#[derive(Debug)]

pub struct AccessError();

pub struct ServerGreetings {

    pub for_latest_protocol: String,

    pub for_old_protocols: String,

}

impl ServerGreetings {

    fn new() -> Self {

        Self {

            for_latest_protocol: "\u{1f994} is watching".to_string(),

            for_old_protocols: "\u{1f994} is watching".to_string(),

        }

    }

}

bitflags! {

    pub struct ServerFlags: u8 {

        const REGISTERED_ONLY = 0b0000_1000;

    }

}

pub struct HwChecker {

    pub id: ClientId,

    pub is_ready: bool,

}

impl HwChecker {

    pub fn new(id: ClientId) -> Self {

        Self {

            id,

            is_ready: false,

        }

    }

    pub fn set_is_ready(&mut self, ready: bool) {

        self.is_ready = ready

    }

}

pub struct HwServer {

    clients: IndexSlab<HwClient>,

    rooms: Slab<HwRoom>,

    checkers: IndexSlab<HwChecker>,

    latest_protocol: u16,

    flags: ServerFlags,

    greetings: ServerGreetings,

    replay_storage: Option<ReplayStorage>,

}

impl HwServer {

    pub fn new(clients_limit: usize, rooms_limit: usize) -> Self {

        todo!("add reconnection IDs");

        let rooms = Slab::with_capacity(rooms_limit);

        let clients = IndexSlab::with_capacity(clients_limit);

        let checkers = IndexSlab::new();

        Self {

            clients,

            rooms,

            checkers,

            greetings: ServerGreetings::new(),

            latest_protocol: 58,

            flags: ServerFlags::empty(),

            replay_storage: None,

        }

    }

    #[inline]

    pub fn client(&self, client_id: ClientId) -> &HwClient {

        &self.clients[client_id]

    }

    #[inline]

    pub fn get_checker_mut(&mut self, checker_id: CheckerId) -> Option<&mut HwChecker> {

        self.checkers.get_mut(checker_id)

    }

    #[inline]

    pub fn has_client(&self, client_id: ClientId) -> bool {

        self.clients.contains(client_id)

    }

    #[inline]

    pub fn iter_clients(&self) -> impl Iterator<Item = &HwClient> + Clone {

        self.clients.iter().map(|(_, c)| c)

    }

    #[inline]

    pub fn room(&self, room_id: RoomId) -> &HwRoom {

        &self.rooms[room_id]

    }

    #[inline]

    pub fn get_room(&self, room_id: RoomId) -> Option<&HwRoom> {

        self.rooms.get(room_id)

    }

    #[inline]

    fn get_room_mut(&mut self, room_id: RoomId) -> Option<&mut HwRoom> {

        self.rooms.get_mut(room_id)

    }

    #[inline]

    pub fn iter_rooms(&self) -> impl Iterator<Item = &HwRoom> {

        self.rooms.iter().map(|(_, r)| r)

    }

    #[inline]

    pub fn client_and_room(&self, client_id: ClientId, room_id: RoomId) -> (&HwClient, &HwRoom) {

        (&self.clients[client_id], &self.rooms[room_id])

    }

    #[inline]

    fn client_and_room_mut(&mut self, client_id: ClientId) -> Option<(&mut HwClient, &mut HwRoom)> {

        let client = &mut self.clients[client_id];

        if let Some(room_id) = client.room_id {

            Some((client, &mut self.rooms[room_id]))

        } else {

            None

        }

    }

    #[inline]

    pub fn get_room_control(&mut self, client_id: ClientId) -> Option<HwRoomControl> {

        HwRoomControl::new(self, client_id)

    }

    #[inline]

    pub fn is_admin(&self, client_id: ClientId) -> bool {

        self.clients

            .get(client_id)

            .map(|c| c.is_admin())

            .unwrap_or(false)

    }

    #[inline]

    pub fn is_checker(&self, client_id: ClientId) -> bool {

        self.checkers.contains(client_id)

    }

    pub fn add_client(&mut self, client_id: ClientId, data: HwAnteroomClient) {

        if data.is_checker {

            self.checkers.insert(client_id, HwChecker::new(client_id));

        } else if let (Some(protocol), Some(nick)) = (data.protocol_number, data.nick) {

            let mut client = HwClient::new(client_id, protocol.get(), nick);

            #[cfg(not(feature = "official-server"))]

            client.set_is_admin(data.is_local_admin);

            #[cfg(feature = "official-server")]

            {

                client.set_is_registered(data.is_registered);

                client.set_is_admin(data.is_admin);

                client.set_is_contributor(data.is_contributor);

            }

            self.clients.insert(client_id, client);

        }

    }

    pub fn remove_client(&mut self, client_id: ClientId) {

        self.clients.remove(client_id);

    }

    pub fn get_greetings(&self, client: &HwClient) -> &str {

        if client.protocol_number < self.latest_protocol {

            &self.greetings.for_old_protocols

        } else {

            &self.greetings.for_latest_protocol

        }

    }

    #[inline]

    pub fn create_room(

        &mut self,

        creator_id: ClientId,

        name: String,

        password: Option<String>,

    ) -> Result<(&HwClient, &HwRoom), CreateRoomError> {

        use CreateRoomError::*;

        if utils::is_name_illegal(&name) {

            Err(InvalidName)

        } else if self.has_room(&name) {

            Err(AlreadyExists)

        } else {

            Ok(create_room(

                &mut self.clients[creator_id],

                &mut self.rooms,

                name,

                password,

            ))

        }

    }

    pub fn join_room(

        &mut self,

        client_id: ClientId,

        room_id: RoomId,

        room_password: Option<&str>,

    ) -> Result<(&HwClient, &HwRoom, impl Iterator<Item = &HwClient> + Clone), JoinRoomError> {

        use JoinRoomError::*;

        let room = &mut self.rooms[room_id];

        let client = &mut self.clients[client_id];

        if client.protocol_number != room.protocol_number {

            Err(WrongProtocol)

        } else if room.password.is_some()

            && room_password != room.password.as_deref()

            && !client.has_super_power()

        {

            Err(WrongPassword)

        } else if room.is_join_restricted() {

            Err(Restricted)

        } else if room.is_registration_required() {

            Err(RegistrationRequired)

        } else if room.players_number == u8::max_value() {

            Err(Full)

        } else {

            move_to_room(client, room);

            let room_id = room.id;

            Ok((

                &self.clients[client_id],

                &self.rooms[room_id],

                self.iter_clients()

                    .filter(move |c| c.room_id == Some(room_id)),

            ))

        }

    }

    #[inline]

    pub fn join_room_by_name(

        &mut self,

        client_id: ClientId,

        room_name: &str,

        room_password: Option<&str>,

    ) -> Result<(&HwClient, &HwRoom, impl Iterator<Item = &HwClient> + Clone), JoinRoomError> {

        use JoinRoomError::*;

        let room = self.rooms.iter().find(|(_, r)| r.name == room_name);

        if let Some((_, room)) = room {

            let room_id = room.id;

            self.join_room(client_id, room_id, room_password)

        } else {

            Err(DoesntExist)

        }

    }

    pub fn enable_super_power(&mut self, client_id: ClientId) -> bool {

        let client = &mut self.clients[client_id];

        if client.is_admin() {

            client.set_has_super_power(true);

        }

        client.is_admin()

    }

    #[inline]

    pub fn set_var(&mut self, client_id: ClientId, var: ServerVar) -> Result<(), AccessError> {

        if self.clients[client_id].is_admin() {

            match var {

                ServerVar::MOTDNew(msg) => self.greetings.for_latest_protocol = msg,

                ServerVar::MOTDOld(msg) => self.greetings.for_old_protocols = msg,

                ServerVar::LatestProto(n) => self.latest_protocol = n,

            }

            Ok(())

        } else {

            Err(AccessError())

        }

    }

    #[inline]

    pub fn get_vars(&self, client_id: ClientId) -> Result<[ServerVar; 3], AccessError> {

        if self.clients[client_id].is_admin() {

            Ok([

                ServerVar::MOTDNew(self.greetings.for_latest_protocol.clone()),

                ServerVar::MOTDOld(self.greetings.for_old_protocols.clone()),

                ServerVar::LatestProto(self.latest_protocol),

            ])

        } else {

            Err(AccessError())

        }

    }

    pub fn get_used_protocols(&self, client_id: ClientId) -> Result<Vec<u16>, AccessError> {

        if self.clients[client_id].is_admin() {

            let mut protocols: HashSet<_> = self

                .clients

                .iter()

                .map(|(_, c)| c.protocol_number)

                .chain(self.rooms.iter().map(|(_, r)| r.protocol_number))

                .collect();

            let mut protocols: Vec<_> = protocols.drain().collect();

            protocols.sort();

            Ok(protocols)

        } else {

            Err(AccessError())

        }

    }

    #[inline]

    pub fn has_room(&self, name: &str) -> bool {

        self.find_room(name).is_some()

    }

    #[inline]

    pub fn find_room(&self, name: &str) -> Option<&HwRoom> {

        self.rooms

            .iter()

            .find_map(|(_, r)| Some(r).filter(|r| r.name == name))

    }

    fn find_room_mut(&mut self, name: &str) -> Option<&mut HwRoom> {

        self.rooms

            .iter_mut()

            .find_map(|(_, r)| Some(r).filter(|r| r.name == name))

    }

    pub fn find_client(&self, nick: &str) -> Option<&HwClient> {

        self.clients

            .iter()

            .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))

    }

    fn find_client_mut(&mut self, nick: &str) -> Option<&mut HwClient> {

        self.clients

            .iter_mut()

            .find_map(|(_, c)| Some(c).filter(|c| c.nick == nick))

    }

    pub fn iter_client_ids(&self) -> impl Iterator<Item = ClientId> + '_ {

        self.clients.iter().map(|(id, _)| id)

    }

    pub fn filter_clients<'a, F>(&'a self, f: F) -> impl Iterator<Item = ClientId> + 'a

    where

        F: Fn(&(usize, &HwClient)) -> bool + 'a,

    {

        self.clients.iter().filter(f).map(|(_, c)| c.id)

    }

    pub fn filter_rooms<'a, F>(&'a self, f: F) -> impl Iterator<Item = RoomId> + 'a