use std::time::SystemTime;

use elseware::common::serverstate::{ClientId, ServerState};
use elseware::entity::gateway::EntityGateway;
use elseware::entity::account::{UserAccountEntity, NewUserAccountEntity, NewUserSettingsEntity};
use elseware::entity::character::{CharacterEntity, NewCharacterEntity};
use elseware::ship::ship::{ShipServerState, RecvShipPacket};

use libpso::packet::ship::*;
use libpso::packet::login::{Login, Session};
use libpso::{utf8_to_array, utf8_to_utf16_array};


pub async fn new_user_character<EG: EntityGateway>(entity_gateway: &mut EG, username: &str, password: &str) -> (UserAccountEntity, CharacterEntity) {
    let new_user = NewUserAccountEntity {
        username: username.into(),
        password: bcrypt::hash(password, 5).unwrap(),
        guildcard: 1,
        team_id: None,
        banned: false,
        muted_until: SystemTime::now(),
        created_at: SystemTime::now(),
        flags: 0,
    };

    let user = entity_gateway.create_user(new_user).await.unwrap();
    let new_settings = NewUserSettingsEntity::new(user.id);
    let _settings = entity_gateway.create_user_settings(new_settings).await.unwrap();
    let new_character = NewCharacterEntity::new(user.id);
    let character = entity_gateway.create_character(new_character).await.unwrap();

    (user, character)
}

pub async fn log_in_char<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, username: &str, password: &str) {
    let username = username.to_string();
    let password = password.to_string();
    ship.handle(id, &RecvShipPacket::Login(Login {
        tag: 0,
        guildcard: 0,
        version: 0,
        unknown1: [0; 6],
        team: 0,
        username: utf8_to_array!(username, 16),
        unknown2: [0; 32],
        password: utf8_to_array!(password, 16),
        unknown3: [0; 40],
        hwinfo: [0; 8],
        session: Session::new(),
    })).await.unwrap().for_each(drop);
}

pub async fn join_lobby<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId) {
    ship.handle(id, &RecvShipPacket::CharData(CharData {
        _unknown: [0; 0x828]
    })).await.unwrap().for_each(drop);
}

pub async fn create_room<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, name: &str, password: &str) {
    ship.handle(id, &RecvShipPacket::CreateRoom(CreateRoom {
        unknown: [0; 2],
        name: utf8_to_utf16_array!(name, 16),
        password: utf8_to_utf16_array!(password, 16),
        difficulty: 0,
        battle: 0,
        challenge: 0,
        episode: 1,
        single_player: 0,
        padding: [0; 3],
    })).await.unwrap().for_each(drop);
    ship.handle(id, &RecvShipPacket::DoneBursting(DoneBursting {})).await.unwrap().for_each(drop);
}

pub async fn join_room<EG: EntityGateway>(ship: &mut ShipServerState<EG>, id: ClientId, room_id: u32) {
    ship.handle(id, &RecvShipPacket::MenuSelect(MenuSelect {
        menu: ROOM_MENU_ID,
        item: room_id,
    })).await.unwrap().for_each(drop);
}