use std::io::Read;
use std::collections::HashMap;

use rand::Rng;
use crc::{crc32, Hasher32};

use libpso::packet::login::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::bb::PSOBBCipher;
use crate::entity::item;
use libpso::character::character;

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

use crate::entity::gateway::EntityGateway;
use crate::entity::account::{UserAccount, USERFLAG_NEWCHAR, USERFLAG_DRESSINGROOM};
use crate::entity::item::{ItemDetail, ItemLocation};
use crate::entity::item::weapon::Weapon;
use crate::entity::item::armor::Armor;
use crate::entity::item::tech::Technique;
use crate::entity::item::tool::Tool;
use crate::entity::item::mag::{Mag, MagType, PhotonBlast};
use crate::entity::character::{Character, CharacterClass, TechLevel};

use crate::login::login::get_login_status;

pub const CHARACTER_PORT: u16 = 12001;
const SHIP_MENU_ID: u32 = 1;

#[derive(Debug)]
pub enum CharacterError {
    InvalidMenuSelection(u32, u32),
    ClientNotFound(ClientId),
}

#[derive(Debug)]
pub enum RecvCharacterPacket {
    Login(Login),
    RequestSettings(RequestSettings),
    CharSelect(CharSelect),
    Checksum(Checksum),
    GuildcardDataRequest(GuildcardDataRequest),
    GuildcardDataChunkRequest(GuildcardDataChunkRequest),
    ParamDataRequest(ParamDataRequest),
    ParamDataChunkRequest(ParamDataChunkRequest),
    CharacterPreview(CharacterPreview),
    SetFlag(SetFlag),
    MenuSelect(MenuSelect),
}

impl RecvServerPacket for RecvCharacterPacket {
    fn from_bytes(data: &[u8]) -> Result<RecvCharacterPacket, PacketParseError> {
        match u16::from_le_bytes([data[2], data[3]]) {
            0x93 => Ok(RecvCharacterPacket::Login(Login::from_bytes(data)?)),
            0xE0 => Ok(RecvCharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)),
            0xE3 => Ok(RecvCharacterPacket::CharSelect(CharSelect::from_bytes(data)?)),
            0x1E8 => Ok(RecvCharacterPacket::Checksum(Checksum::from_bytes(data)?)),
            0x3E8 => Ok(RecvCharacterPacket::GuildcardDataRequest(GuildcardDataRequest::from_bytes(data)?)),
            0x3DC => Ok(RecvCharacterPacket::GuildcardDataChunkRequest(GuildcardDataChunkRequest::from_bytes(data)?)),
            0x4EB => Ok(RecvCharacterPacket::ParamDataRequest(ParamDataRequest::from_bytes(data)?)),
            0x3EB => Ok(RecvCharacterPacket::ParamDataChunkRequest(ParamDataChunkRequest::from_bytes(data)?)),
            0xE5 => Ok(RecvCharacterPacket::CharacterPreview(CharacterPreview::from_bytes(data)?)),
            0xEC => Ok(RecvCharacterPacket::SetFlag(SetFlag::from_bytes(data)?)),
            0x10 => Ok(RecvCharacterPacket::MenuSelect(MenuSelect::from_bytes(data)?)),
            _ => Err(PacketParseError::WrongPacketForServerType(u16::from_le_bytes([data[2], data[3]]), data.to_vec()))
        }
    }
}


#[derive(Debug)]
pub enum SendCharacterPacket {
    LoginResponse(LoginResponse),
    LoginWelcome(LoginWelcome),
    SendKeyAndTeamSettings(SendKeyAndTeamSettings),
    CharAck(CharAck),
    ChecksumAck(ChecksumAck),
    CharacterPreview(CharacterPreview),
    GuildcardDataHeader(GuildcardDataHeader),
    GuildcardDataChunk(GuildcardDataChunk),
    ParamDataHeader(ParamDataHeader),
    ParamDataChunk(ParamDataChunk),
    Timestamp(Timestamp),
    ShipList(ShipList),
    RedirectClient(RedirectClient),
}

impl SendServerPacket for SendCharacterPacket {
    fn as_bytes(&self) -> Vec<u8> {
        match self {
            SendCharacterPacket::LoginResponse(pkt) => pkt.as_bytes(),
            SendCharacterPacket::LoginWelcome(pkt) => pkt.as_bytes(),
            SendCharacterPacket::SendKeyAndTeamSettings(pkt) => pkt.as_bytes(),
            SendCharacterPacket::CharAck(pkt) => pkt.as_bytes(),
            SendCharacterPacket::ChecksumAck(pkt) => pkt.as_bytes(),
            SendCharacterPacket::CharacterPreview(pkt) => pkt.as_bytes(),
            SendCharacterPacket::GuildcardDataHeader(pkt) => pkt.as_bytes(),
            SendCharacterPacket::GuildcardDataChunk(pkt) => pkt.as_bytes(),
            SendCharacterPacket::ParamDataHeader(pkt) => pkt.as_bytes(),
            SendCharacterPacket::ParamDataChunk(pkt) => pkt.as_bytes(),
            SendCharacterPacket::Timestamp(pkt) => pkt.as_bytes(),
            SendCharacterPacket::ShipList(pkt) => pkt.as_bytes(),
            SendCharacterPacket::RedirectClient(pkt) => pkt.as_bytes(),
        }
    }
}


fn generate_param_data(path: &str) -> (ParamDataHeader, Vec<u8>) {
    let paths = std::fs::read_dir(path).expect("could not find param/ directory");

    let mut files = Vec::new();
    let mut buffer = Vec::new();
    for p in paths {
        let param = p.unwrap().path();
        let mut file = std::fs::File::open(&param).unwrap();

        let mut filebuf = Vec::new();
        let len = file.read_to_end(&mut filebuf).unwrap();

        let mut crc = crc32::Digest::new(crc32::IEEE);
        crc.write(&filebuf[..]);

        files.push(ParamFile {
            size: len as u32,
            checksum: crc.sum32(),
            offset: buffer.len() as u32,
            filename: utf8_to_array!(param.file_name().unwrap().to_str().unwrap(), 0x40),
        });

        buffer.append(&mut filebuf);
    }

    (ParamDataHeader {
        files: files
    }, buffer)
}

#[derive(Clone)]
struct ClientState {
    param_index: usize,
    user: Option<UserAccount>,
    characters: Option<[Option<Character>; 4]>,
    guildcard_data_buffer: Option<Vec<u8>>,
    session: Session,
}

impl ClientState {
    fn new() -> ClientState {
        ClientState {
            param_index: 0,
            user: None,
            characters: None,
            guildcard_data_buffer: None,
            session: Session::new(),
        }
    }
}


struct Ship {
    flags: u32,
    name: String,
    ip: [u8; 4],
    port: u16,
}

impl Ship {
    fn new(name: &str, ip: [u8; 4], port: u16) -> Ship {
        Ship {
            flags: 0,
            name: name.to_owned(),
            ip: ip,
            port: port,
        }
    }
}

pub struct CharacterServerState<EG: EntityGateway> {
    entity_gateway: EG,
    param_header: ParamDataHeader,
    param_data: Vec<u8>,
    clients: HashMap<ClientId, ClientState>,
    ships: Vec<Ship>,
    level_table: CharacterLevelTable,
}


fn new_character<EG: EntityGateway>(entity_gateway: &mut EG, user: &UserAccount, preview: &CharacterPreview) {
    let mut char = entity_gateway.new_character_by_user(&user);
    new_character_from_preview(&mut char, preview);
    match char.char_class {
        CharacterClass::FOmar | CharacterClass::FOmarl| CharacterClass::FOnewm | CharacterClass::FOnewearl => char.techs.set_tech(Technique::Foie, TechLevel(1)),
        _ => {}
    }

    entity_gateway.set_character(&char);

    let new_weapon = match char.char_class {
        CharacterClass::HUmar | CharacterClass::HUnewearl | CharacterClass::HUcast | CharacterClass::HUcaseal => item::weapon::WeaponType::Saber,
        CharacterClass::RAmar | CharacterClass::RAmarl | CharacterClass::RAcast | CharacterClass::RAcaseal => item::weapon::WeaponType::Handgun,
        CharacterClass::FOmar | CharacterClass::FOmarl | CharacterClass::FOnewm | CharacterClass::FOnewearl => item::weapon::WeaponType::Cane,
    };

    entity_gateway.new_item(
        ItemDetail::Weapon(
            Weapon {
                weapon: new_weapon,
                grind: 0,
                special: None,
                attrs: [None; 3],
                equipped: true,
                tekked: true,
            }),
        ItemLocation::Inventory {
            character_id: char.id,
            index: 0,
        });

    entity_gateway.new_item(
        ItemDetail::Armor (
            Armor {
                armor: item::armor::ArmorType::Frame,
                dfp: 0,
                evp: 0,
                slots: 0,
                equipped: true,
            }),
        ItemLocation::Inventory {
            character_id: char.id,
            index: 1,
        });

    entity_gateway.new_item(
        ItemDetail::Mag(
            Mag {
                mag: MagType::Mag,
                def: 500,
                pow: 0,
                dex: 0,
                mnd: 0,
                synchro: 20,
                iq: 0,
                photon_blast: [None; 3],
                equipped: true,
            }),
            ItemLocation::Inventory {
                character_id: char.id,
                index: 2,
            });

    for _ in 0..4 {
        entity_gateway.new_item(
            ItemDetail::Tool (
                Tool {
                    tool: item::tool::ToolType::Monomate,
                }),
            ItemLocation::Inventory {
                character_id: char.id,
                index: 3,
            });
        entity_gateway.new_item(
            ItemDetail::Tool (
                Tool {
                    tool: item::tool::ToolType::Monofluid,
                }),
            ItemLocation::Inventory {
                character_id: char.id,
                index: 4,
            });
    }
}



impl<EG: EntityGateway> CharacterServerState<EG> {
    pub fn new(entity_gateway: EG) -> CharacterServerState<EG> {
        let (param_header, param_data) = generate_param_data("data/param/");

        let ships = vec![Ship::new("Sona-Nyl", [127,0,0,1], 23423),
                         Ship::new("Dylath-Leen", [127,0,0,1], 23424),
                         Ship::new("Thalarion", [127,0,0,1], 23425),
        ];
        CharacterServerState {
            entity_gateway: entity_gateway,
            param_header: param_header,
            param_data: param_data,
            clients: HashMap::new(),
            ships: ships,
            level_table: CharacterLevelTable::new(),
        }
    }

    fn validate_login(&mut self, id: ClientId, pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        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;
                response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
                client.user = Some(user);
                client.session = pkt.session;
                vec![SendCharacterPacket::LoginResponse(response)]
            },
            Err(err) => {
                vec![SendCharacterPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]
            }
        })
    }

    fn send_ship_list(&mut self, _id: ClientId, _pkt: &Login) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        Ok(vec![SendCharacterPacket::Timestamp(Timestamp::new(chrono::Utc::now())),
                SendCharacterPacket::ShipList(ShipList::new(self.ships.iter().enumerate().map(|(i, s)| {
                    ShipListEntry {
                        menu: SHIP_MENU_ID,
                        item: i as u32,
                        flags: 0,
                        name: utf8_to_utf16_array!(s.name, 0x11)
                    }
                }).collect()))
        ])
    }

    fn get_settings(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        let user = client.user.as_ref().unwrap();

        // TODO: this should error (data should be added on account creation, why did I copy this silly sylv logic?)
        let settings = match self.entity_gateway.get_user_settings_by_user(&user) {
            Some(settings) => settings,
            None => self.entity_gateway.create_user_settings_by_user(&user),
        };

        let pkt = SendKeyAndTeamSettings::new(settings.settings.key_config,
                                              settings.settings.joystick_config, 0, 0);
        let pkt = SendCharacterPacket::SendKeyAndTeamSettings(pkt);

        Ok(vec![pkt])
    }

    fn char_select(&mut self, id: ClientId, select: &CharSelect) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        if client.characters.is_none() {
            client.characters = Some(self.entity_gateway.get_characters_by_user(client.user.as_ref().unwrap()));
        }

        if select.reason == 0 {
            let chars = client.characters.as_ref().unwrap();
            Ok(if let Some(char) = &chars[select.slot as usize] {
                let (level, stats) = self.level_table.get_stats_from_exp(char.char_class, char.exp);
                vec![SendCharacterPacket::CharacterPreview(CharacterPreview {
                    slot: select.slot,
                    character: SelectScreenCharacterBuilder::new()
                        .character(&char)
                        .level(level)
                        .build()
                })]
            }
               else {
                   vec![SendCharacterPacket::CharAck(CharAck {
                       slot: select.slot,
                       code: 2,
                   })]
               })
        }
        else {
            let user = client.user.as_ref().unwrap();
            client.session.action = SessionAction::SelectCharacter;
            client.session.character_slot = select.slot as u8;
            Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard,
                                                                                     user.team_id.unwrap_or(1),
                                                                                     client.session)),
                    SendCharacterPacket::CharAck(CharAck {
                        slot: select.slot,
                        code: 1,
                    })
            ])
        }
    }

    fn validate_checksum(&mut self) -> Vec<SendCharacterPacket> {
        vec![SendCharacterPacket::ChecksumAck(ChecksumAck {
            ack: 1,
        })]
    }

    fn guildcard_data_header(&mut self, id: ClientId) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        let guildcard_data = self.entity_gateway.get_guild_card_data_by_user(client.user.as_ref().unwrap());

        let bytes = guildcard_data.guildcard.as_bytes();
        let mut crc = crc32::Digest::new(crc32::IEEE);
        crc.write(&bytes[..]);
        client.guildcard_data_buffer = Some(bytes.to_vec());

        Ok(vec![SendCharacterPacket::GuildcardDataHeader(GuildcardDataHeader::new(bytes.len(), crc.sum32()))])
    }

    fn guildcard_data_chunk(&mut self, id: ClientId, chunk: u32, again: u32) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        Ok(if again != 0 {
            let start = chunk as usize * GUILD_CARD_CHUNK_SIZE;
            let len = std::cmp::min(GUILD_CARD_CHUNK_SIZE, client.guildcard_data_buffer.as_ref().unwrap().len() as usize - start);
            let end = start + len;

            let mut buf = [0u8; GUILD_CARD_CHUNK_SIZE as usize];
            buf[..len as usize].copy_from_slice(&client.guildcard_data_buffer.as_ref().unwrap()[start..end]);

            vec![SendCharacterPacket::GuildcardDataChunk(GuildcardDataChunk::new(chunk, buf, len))]
        } else {
            Vec::new()
        })
    }

    fn set_flag(&mut self, id: ClientId, setflag: &SetFlag) -> Result<std::option::IntoIter<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        let mut user = client.user.as_mut().unwrap();
        user.flags = setflag.flags;
        self.entity_gateway.set_user(&user);
        Ok(None.into_iter())
    }

    fn param_data_chunk_request(&mut self, id: ClientId, _request: &ParamDataChunkRequest) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        let chunk = client.param_index;
        client.param_index += 1;

        let start = chunk * 0x6800;
        let end = std::cmp::min((chunk+1)*0x6800, self.param_data.len());

        let mut data = [0u8; 0x6800];
        data[..end-start].copy_from_slice(&self.param_data[start..end]);

        Ok(vec![SendCharacterPacket::ParamDataChunk(
            ParamDataChunk {
                chunk: chunk as u32,
                data: data,
            }
        )])
    }


    // TODO: move USERFLAGS over to SessionAction
    fn character_preview(&mut self, id: ClientId, preview: &CharacterPreview) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        let client = self.clients.get_mut(&id).ok_or(CharacterError::ClientNotFound(id))?;
        let mut user = client.user.as_mut().unwrap();
        if user.flags == USERFLAG_NEWCHAR {
            new_character(&mut self.entity_gateway, &user, preview)
        }
        if user.flags == USERFLAG_DRESSINGROOM {
            // TODO: dressing room stuff
        }

        client.session.action = SessionAction::SelectCharacter;
        client.session.character_slot = preview.slot as u8;
        user.flags = 0;
        self.entity_gateway.set_user(&user);
        Ok(vec![SendCharacterPacket::LoginResponse(LoginResponse::by_char_select(user.guildcard,
                                                                                 user.team_id.unwrap_or(1),
                                                                                 client.session)),
                SendCharacterPacket::CharAck(CharAck {
                    slot: preview.slot,
                    code: 0
                })
        ])
    }

    fn select_ship(&mut self, menuselect: &MenuSelect) -> Result<Vec<SendCharacterPacket>, CharacterError> {
        if menuselect.menu != SHIP_MENU_ID {
           return Err(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item));
        }

        let ship = self.ships.get(menuselect.item as usize)
                             .ok_or(CharacterError::InvalidMenuSelection(menuselect.menu, menuselect.item))?;
        Ok(vec![SendCharacterPacket::RedirectClient(RedirectClient::new(u32::from_le_bytes(ship.ip), ship.port))])
    }
}

impl<EG: EntityGateway> ServerState for CharacterServerState<EG> {
    type SendPacket = SendCharacterPacket;
    type RecvPacket = RecvCharacterPacket;
    type PacketError = CharacterError;

    fn on_connect(&mut self, id: ClientId) -> Vec<OnConnect<Self::SendPacket>> {
        self.clients.insert(id, ClientState::new());

        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(SendCharacterPacket::LoginWelcome(LoginWelcome::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: &RecvCharacterPacket)
              -> Result<Box<dyn Iterator<Item = (ClientId, SendCharacterPacket)> + Send>, CharacterError> {
        Ok(match pkt {
            RecvCharacterPacket::Login(login) => {
                if login.session.action == SessionAction::SelectCharacter {
                    Box::new(self.send_ship_list(id, login)?.into_iter().map(move |pkt| (id, pkt)))
                }
                else {
                    Box::new(self.validate_login(id, login)?.into_iter().map(move |pkt| (id, pkt)))
                }
            },
            RecvCharacterPacket::RequestSettings(_req) => {
                Box::new(self.get_settings(id)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::CharSelect(sel) => {
                Box::new(self.char_select(id, sel)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::Checksum(_checksum) => {
                Box::new(self.validate_checksum().into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::GuildcardDataRequest(_request) => {
                Box::new(self.guildcard_data_header(id)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::GuildcardDataChunkRequest(request) => {
                Box::new(self.guildcard_data_chunk(id, request.chunk, request.again)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::ParamDataRequest(_request) => {
                Box::new(vec![SendCharacterPacket::ParamDataHeader(self.param_header.clone())].into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::SetFlag(flag) => {
                Box::new(self.set_flag(id, flag)?.map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::ParamDataChunkRequest(request) => {
                Box::new(self.param_data_chunk_request(id, request)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::CharacterPreview(preview) => {
                Box::new(self.character_preview(id, preview)?.into_iter().map(move |pkt| (id, pkt)))
            },
            RecvCharacterPacket::MenuSelect(menuselect) => {
                Box::new(self.select_ship(menuselect)?.into_iter().map(move |pkt| (id, pkt)))
            }
        })
    }

    fn on_disconnect(&mut self, id: ClientId) -> Vec<(ClientId, SendCharacterPacket)> {
        Vec::new()
    }
}


fn new_character_from_preview(character: &mut Character, preview: &CharacterPreview) {
    character.slot = preview.slot;
    character.name = String::from_utf16_lossy(&preview.character.name).trim_matches(char::from(0)).into();
    character.section_id = preview.character.section_id.into();
    character.char_class = preview.character.ch_class.into();
    character.appearance.costume = preview.character.costume;
    character.appearance.skin = preview.character.skin;
    character.appearance.face = preview.character.face;
    character.appearance.head = preview.character.head;
    character.appearance.hair = preview.character.hair;
    character.appearance.hair_r = preview.character.hair_r;
    character.appearance.hair_g = preview.character.hair_g;
    character.appearance.hair_b = preview.character.hair_b;
    character.appearance.prop_x = preview.character.prop_x;
    character.appearance.prop_y = preview.character.prop_y;
}


struct SelectScreenCharacterBuilder<'a> {
    character: Option<&'a Character>,
    level: Option<u32>,
}

impl<'a> SelectScreenCharacterBuilder<'a> {
    fn new() -> SelectScreenCharacterBuilder<'a> {
        SelectScreenCharacterBuilder {
            character: None,
            level: None,
        }
    }

    fn character(self, character: &'a Character) -> SelectScreenCharacterBuilder<'a> {
        SelectScreenCharacterBuilder {
            character: Some(character),
            ..self
        }
    }

    fn level(self, level: u32) -> SelectScreenCharacterBuilder<'a> {
        SelectScreenCharacterBuilder {
            level: Some(level),
            ..self
        }
    }

    fn build(self) -> character::SelectScreenCharacter {
        let character = self.character.unwrap();
        let level = self.level.unwrap();

        character::SelectScreenCharacter {
            //exp: character.exp,
            level: level - 1,
            //guildcard: character.guildcard,
            //_unknown: character._unknown3,
            //name_color: character.name_color,
            //model: character.model,
            //_unused: [0; 15],
            //name_color_checksum: character.name_color_checksum,
            section_id: character.section_id.into(),
            ch_class: character.char_class.into(),
            //v2flags: character.v2flags,
            //version: character.version,
            //v1flags: character.v1flags,
            costume: character.appearance.costume,
            skin: character.appearance.skin,
            face: character.appearance.face,
            head: character.appearance.head,
            hair: character.appearance.hair,
            hair_r: character.appearance.hair_r,
            hair_g: character.appearance.hair_g,
            hair_b: character.appearance.hair_b,
            prop_x: character.appearance.prop_x,
            prop_y: character.appearance.prop_y,
            name: utf8_to_utf16_array!(character.name, 16),
            //play_time: character.play_time,
            ..character::SelectScreenCharacter::default()
        }
    }
}


#[cfg(test)]
mod test {
    use super::*;
    use crate::entity::account::UserSettings;
    use libpso::character::{settings, character};
    use std::time::SystemTime;
    use crate::entity::gateway::{InMemoryGateway};

    #[test]
    fn test_option_send() {
        struct TestData {
        }

        impl EntityGateway for TestData {
            fn get_user_settings_by_user(&self, _user: &UserAccount) -> Option<UserSettings> {
                Some(UserSettings {
                    id: 0,
                    user_id: 0,
                    settings: settings::UserSettings::default()
                })
            }
        }

        let mut server = CharacterServerState::new(TestData {});
        let mut clientstate = ClientState::new();
        clientstate.user = Some(UserAccount {
            id: 1,
            username: "testuser".to_owned(),
            password: bcrypt::hash("mypassword", 5).unwrap(),
            guildcard: 0,
            team_id: None,
            banned: false,
            muted_until: SystemTime::now(),
            created_at: SystemTime::now(),
            flags: 0,
        });
        server.clients.insert(ClientId(5), clientstate);

        let send = server.handle(ClientId(5), &RecvCharacterPacket::RequestSettings(RequestSettings{}))
            .unwrap()
            .collect::<Vec<_>>();
        assert!(send.len() == 1);

        assert!(send[0].0 == ClientId(5));
        let bytes = send[0].1.as_bytes();
        assert!(bytes[2] == 0xE2);
        assert!(bytes.len() == 0xAFC);
    }

    #[test]
    fn test_user_checksum() {
        struct TestData;
        impl EntityGateway for TestData {}
        let mut server = CharacterServerState::new(TestData {});
        let send = server.handle(ClientId(1), &RecvCharacterPacket::Checksum(Checksum {checksum: 1234,
                                                                                       padding: 0,
        })).unwrap().collect::<Vec<_>>();
        assert!(send.len() == 1);

        let bytes = send[0].1.as_bytes();
        assert!(bytes == [0xC, 0, 0xE8, 0x02, 0,0,0,0, 1,0,0,0]);
    }

    #[test]
    fn test_character_create() {
        let TestData = InMemoryGateway::new();
        let mut fake_user = ClientState::new();
        fake_user.user = Some(UserAccount {
            id: 3,
            username: "hi3".to_string(),
            password: bcrypt::hash("qwer", 5).unwrap(),
            guildcard: 3,
            team_id: None,
            banned: false,
            muted_until: SystemTime::now(),
            created_at: SystemTime::now(),
            flags: 0,
        });

        let mut server = CharacterServerState::new(TestData.clone());
        server.clients.insert(ClientId(1), fake_user.clone());
        let mut send = server.handle(ClientId(1), &RecvCharacterPacket::SetFlag(SetFlag {flags: 1})).unwrap().collect::<Vec<_>>();
        assert!(TestData.get_user_by_id(3).unwrap().flags == 1);
        send = server.handle(ClientId(1), &RecvCharacterPacket::CharacterPreview(CharacterPreview {slot: 1, character: character::SelectScreenCharacter {
            exp: 0,
            level: 0,
            guildcard: [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
            _unknown: [0, 0],
            name_color: 4294967295,
            model: 0,
            _unused: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
            name_color_checksum: 0,
            section_id: 4,
            ch_class: 2,
            v2flags: 0,
            version: 3,
            v1flags: 49,
            costume: 0,
            skin: 4,
            face: 0,
            head: 0,
            hair: 0,
            hair_r: 0,
            hair_g: 0,
            hair_b: 0,
            prop_x: 0.33333334,
            prop_y: 0.0,
            name: [9, 69, 116, 101, 115, 116, 32, 110, 97, 109, 101, 0, 0, 0, 0, 0], // "\tEtest name"
            play_time: 0,
        } })).unwrap().collect::<Vec<_>>();
        assert!(send.len() == 2);

        let chars = TestData.get_characters_by_user(&fake_user.user.unwrap());
        assert!(chars[1].as_ref().unwrap().name == "\tEtest name");
        assert!(chars[0].is_none());
    }
}