use libpso::packet::login::{Login, LoginResponse, AccountStatus, Session};
use libpso::packet::ship::*;
use crate::common::serverstate::ClientId;
use crate::ship::ship::{SendShipPacket, ShipError, ClientState, Clients};
use crate::login::login::get_login_status;
use crate::entity::gateway::EntityGateway;
use crate::ship::items::state::ItemState;
use crate::common::interserver::ShipMessage;

#[allow(clippy::too_many_arguments)]
pub async fn validate_login<EG>(id: ClientId,
                                pkt: Login,
                                entity_gateway: &mut EG,
                                clients: &mut Clients,
                                item_state: &mut ItemState,
                                shipgate_sender: &Option<async_std::channel::Sender<ShipMessage>>,
                                ship_name: &str,
                                num_blocks: usize)
                                -> Result<Vec<SendShipPacket>, anyhow::Error>
where
    EG: EntityGateway,
{
    Ok(match get_login_status(entity_gateway, &pkt).await {
        Ok(user) => {
            let mut response = LoginResponse::by_status(AccountStatus::Ok, Session::new());
            response.guildcard = user.id.0;
            response.team_id = user.team_id.map_or(31, |ti| ti);
            let characters = entity_gateway.get_characters_by_user(&user).await?;
            let character = characters
                .get(pkt.session.character_slot as usize)
                .ok_or_else(|| ShipError::InvalidSlot(id, pkt.session.character_slot as u32))?
                .as_ref()
                .ok_or_else(|| ShipError::NoCharacterInSlot(id, pkt.session.character_slot as u32))?
                .clone();
            let settings = entity_gateway.get_user_settings_by_user(&user).await?;

            item_state.load_character(entity_gateway, &character).await?;

            if let Some(shipgate_sender) = shipgate_sender.as_ref() {
                shipgate_sender.send(ShipMessage::AddUser(user.id)).await?;
            }
            clients.add(id, ClientState::new(user, settings, character, pkt.session)).await;
            vec![SendShipPacket::LoginResponse(response), SendShipPacket::ShipBlockList(ShipBlockList::new(ship_name, num_blocks))]
        },
        Err(err) => {
            vec![SendShipPacket::LoginResponse(LoginResponse::by_status(err, Session::new()))]
        }
    })
}