use std::net;

use rand::{Rng, RngCore};
use bcrypt::{DEFAULT_COST, hash, verify};

use libpso::packet::login::*;
use libpso::{PacketParseError, PSOPacket};
use libpso::crypto::{CipherError, PSOCipher, NullCipher};
use libpso::crypto::bb::PSOBBCipher;

use elseware::pktvec;
use elseware::common::pktvec::PktVec;
use elseware::common::cipherkeys::{ELSEWHERE_PRIVATE_KEY, ELSEWHERE_PARRAY};
use elseware::common::network::{PacketNetworkError};
use elseware::common::client::Client;
use elseware::common::serverstate::{ServerPacket, ServerState, OnConnect};
use elseware::common::util::array_to_utf8;

use crate::dataaccess::DataAccess;
use crate::login::{SharedLoginState, get_login_status};
use crate::models::UserAccount;

pub const CHARACTER_PORT: u16 = 12001;

#[derive(Debug)]
pub enum CharacterError {
}

#[derive(Debug)]
pub enum CharacterPacket {
    Login(Login),
    RequestSettings(RequestSettings),
}

impl ServerPacket for CharacterPacket {
    fn from_bytes(data: &Vec<u8>) -> Result<CharacterPacket, PacketParseError> {
        match data[2] {
            0x93 => Ok(CharacterPacket::Login(Login::from_bytes(data)?)),
            0xE0 => Ok(CharacterPacket::RequestSettings(RequestSettings::from_bytes(data)?)),
            _ => Err(PacketParseError::WrongPacketForServerType)
        }
    }
}

pub struct CharacterServerState<DA: DataAccess> {
    shared_state: SharedLoginState<DA>,
    user: Option<UserAccount>,
}

impl<DA: DataAccess> CharacterServerState<DA> {
    fn new(shared_state: SharedLoginState<DA>) -> CharacterServerState<DA> {
        CharacterServerState {
            shared_state: shared_state,
            user: None,
        }
    }

    fn validate_login(&mut self, pkt: &Login) -> Box<PktVec> {
        match get_login_status(&self.shared_state.data_access, pkt) {
            Ok(user) => {
                let mut response = LoginResponse::by_status(AccountStatus::Ok, pkt.security_data);
                response.guildcard = user.guildcard.map_or(0, |gc| gc) as u32;
                response.team_id = user.team_id.map_or(0, |ti| ti) as u32;
                self.user = Some(user);
                pktvec![response]
            },
            Err(err) => {
                pktvec![LoginResponse::by_status(err, pkt.security_data)]
            }
        }
    }

    fn get_settings(&mut self) -> Box<PktVec> {
        pktvec![]
    }
}

impl<DA: DataAccess> ServerState for CharacterServerState<DA> {
    type Packet = CharacterPacket;
    type PacketError = CharacterError;

    fn on_connect(&mut self) -> Vec<OnConnect> {
        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(Box::new(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, pkt: &CharacterPacket) -> Box<dyn Iterator<Item = Box<dyn PSOPacket>>> {
        println!("[character: recv] {:?}", pkt);
        match pkt {
            CharacterPacket::Login(login) => {
                self.validate_login(login)
            },
            CharacterPacket::RequestSettings(_req) => {
                self.get_settings()
            }
        }
    }
}





pub fn new_client<DA: DataAccess + 'static>(socket: mio::tcp::TcpStream, shared_state: SharedLoginState<DA>) {
    let state = CharacterServerState::new(shared_state);
    let client = Client::new(socket, Box::new(state));
    client.io_loop();
}