use std::net;

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

use diesel::r2d2;
use diesel::prelude::*;
use diesel::pg::PgConnection;
use elseware::schema::*;

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::models::UserAccount;

pub const LOGIN_PORT: u16 = 12000;
type ConnectionPool = r2d2::Pool<r2d2::ConnectionManager<PgConnection>>;

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


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

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

#[derive(Clone)]
pub struct SharedLoginState {
    pub connection_pool: ConnectionPool,
}

impl SharedLoginState {
    pub fn new(pool: ConnectionPool) -> SharedLoginState {
        SharedLoginState {
            connection_pool: pool,
        }
    }
}


pub struct LoginServerState {
    pub shared_state: SharedLoginState,
}

pub fn get_login_status(connection_pool: &ConnectionPool, pkt: &Login) -> Result<UserAccount, AccountStatus> {
    use elseware::schema::user_accounts::dsl::{user_accounts, username};
    connection_pool.get()
        .map_err(|_err| AccountStatus::Error)
        .and_then(|conn| {
            array_to_utf8(pkt.username)
                .map(|username_str| {
                    (conn, username_str)
                })
                .map_err(|err| {
                    println!("utf err: {:?}", err);
                    AccountStatus::Error
                })
        })
        .and_then(|(conn, username_str)| {
            user_accounts.filter(username.eq(username_str)).load::<UserAccount>(&conn)
                .map_err(|err| {
                    println!("sql err: {:?}", err);
                    AccountStatus::Error
                })
        })
        .and_then(|mut result| {
            result.pop().ok_or(AccountStatus::InvalidUser)
        })
        .and_then(|user| {
            array_to_utf8(pkt.password)
                .map(|password| {
                    (user, password)
                })
                .map_err(|_err| AccountStatus::Error)
        })
        .and_then(|(user, password)| {
            bcrypt::verify(password, user.password.as_str())
                .map_err(|err| {
                    println!("bcrypt err: {:?}", err);
                    AccountStatus::Error
                })
                .and_then(|correct_password| {
                    match correct_password {
                        true => Ok(user),
                        false => Err(AccountStatus::InvalidPassword),
                    }
                })
        })
}

impl LoginServerState {
    fn new(shared_state: SharedLoginState) -> LoginServerState {
        LoginServerState {
            shared_state: shared_state,
        }
    }

    fn validate_login(&mut self, pkt: &Login) -> Box<PktVec> {
        match get_login_status(&self.shared_state.connection_pool, pkt) {
            Ok(_user) => {
                let response = LoginResponse::by_status(AccountStatus::Ok, pkt.security_data);
                let ip = net::Ipv4Addr::new(127,0,0,1);
                let ip = u32::from_ne_bytes(ip.octets());
                pktvec![response, RedirectClient::new(ip, crate::character::CHARACTER_PORT)]
            },
            Err(err) => {
                pktvec![LoginResponse::by_status(err, pkt.security_data)]
            }
        }
    }
}

impl ServerState for LoginServerState {
    type Packet = LoginPacket;
    type PacketError = LoginError;

    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: &LoginPacket) -> Box<dyn Iterator<Item = Box<dyn PSOPacket>>> {
        println!("[login: recv] {:?}", pkt);
        match pkt {
            LoginPacket::Login(login) => {
                self.validate_login(login)
            }
        }
    }
}




pub fn new_client(socket: mio::tcp::TcpStream, shared_state: SharedLoginState) {
    let state = LoginServerState::new(shared_state);
    let client = Client::new(socket, Box::new(state));
    client.io_loop();
}