use std::collections::HashMap;
use std::env;
use tonic::{Code, Status};
use std::error::Error;
use std::sync::Arc;
use tokio::net::TcpStream;
use tokio::sync::Mutex;
use tracing::{debug, error, info, warn};
use utils::service_discovery;
use crate::auth_client::AuthClient;
use crate::handlers::null_string::NullTerminatedString;
use crate::packet::{send_packet, Packet, PacketPayload};
use crate::packet_type::PacketType;
use crate::packets::cli_accept_req::CliAcceptReq;
use crate::packets::cli_join_server_req::CliJoinServerReq;
use crate::packets::cli_login_req::CliLoginReq;
use crate::packets::{srv_accept_reply, srv_login_reply};
use crate::packets::srv_accept_reply::SrvAcceptReply;
use crate::packets::srv_login_reply::{ServerInfo, SrvLoginReply};

pub(crate) async fn handle_accept_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
    let data = CliAcceptReq::decode(packet.payload.as_slice());
    debug!("{:?}", data);

    // We need to do reply to this packet
    let data = SrvAcceptReply { result: srv_accept_reply::Result::Accepted, rand_value: 0 };
    let response_packet = Packet::new(PacketType::PakssAcceptReply, &data)?;

    debug!("{:?}", response_packet);
    send_packet(stream, &response_packet).await?;
    Ok(())
}

pub(crate) async fn handle_join_server_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
    let data = CliJoinServerReq::decode(packet.payload.as_slice());
    debug!("{:?}", data);
    Ok(())
}

pub(crate) async fn handle_login_req(stream: &mut TcpStream, packet: Packet, auth_client: Arc<Mutex<AuthClient>>) -> Result<(), Box<dyn Error + Send + Sync>> {
    debug!("decoding packet payload of size {}", packet.payload.as_slice().len());
    let data = CliLoginReq::decode(packet.payload.as_slice())?;
    debug!("{:?}", data);

    let mut auth_client = auth_client.lock().await;
    match auth_client.login_token(&data.token.0).await {
        Ok(response) => {
            if response.valid == false {
                info!("Login failed: Invalid credentials");

                let data = SrvLoginReply { result: srv_login_reply::Result::UnknownAccount, right: 0, type_: 0, servers_info: Vec::new() };
                let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                send_packet(stream, &response_packet).await?;
            } else {
                debug!("Successfully logged in");
                
                let consul_url = env::var("CONSUL_URL").unwrap_or_else(|_| "http://127.0.0.1:8500".to_string());
                let servers = service_discovery::get_service_address(&consul_url, "character-service").await.unwrap_or_else(|err| {
                    warn!(err);
                    Vec::new()
                });
                
                if servers.len() == 0 {
                    let data = SrvLoginReply { result: srv_login_reply::Result::Failed, right: 0, type_: 0, servers_info: Vec::new() };
                    let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                    send_packet(stream, &response_packet).await?;
                    return Ok(());
                }
                
                let mut server_info: Vec<ServerInfo> = Vec::new();
                let mut id = 0;
                for server in servers {
                    let name = server.ServiceMeta.get("name").unwrap_or(&"".to_string()).clone();
                    let is_test = server.ServiceTags.contains(&"test".to_string()) || server.ServiceTags.contains(&"staging".to_string());
                    server_info.push(ServerInfo { test: u8::from(is_test), name: NullTerminatedString::new(&name), id});
                    id = id + 1;
                }
                
                let data = SrvLoginReply { result: srv_login_reply::Result::Ok, right: 0, type_: 0, servers_info: server_info };
                let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                send_packet(stream, &response_packet).await?;
            }
        }
        Err(status) => {
            if let Some(tonic_status) = status.downcast_ref::<Status>() {
                match tonic_status.code() {
                    Code::Unauthenticated => {
                        info!("Login failed: Invalid credentials");
    
                        let data = SrvLoginReply { result: srv_login_reply::Result::UnknownAccount, right: 0, type_: 0, servers_info: Vec::new() };
                        let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                        send_packet(stream, &response_packet).await?;
                    }
                    Code::Unavailable => {
                        warn!("Login failed: Service is unavailable");
                        let data = SrvLoginReply { result: srv_login_reply::Result::Failed, right: 0, type_: 0, servers_info: Vec::new() };
                        let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                        send_packet(stream, &response_packet).await?;
                    }
                    _ => {
                        error!("Unexpected error: {}", tonic_status.message());
                        let data = SrvLoginReply { result: srv_login_reply::Result::Failed, right: 0, type_: 0, servers_info: Vec::new() };
                        let response_packet = Packet::new(PacketType::PaklcLoginReply, &data)?;
                        send_packet(stream, &response_packet).await?;
                    }
                }
            }
        }
    }

    Ok(())
}

pub(crate) async fn handle_server_select_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
    let data = CliJoinServerReq::decode(packet.payload.as_slice());
    debug!("{:?}", data);
    Ok(())
}

pub(crate) async fn handle_channel_list_req(stream: &mut TcpStream, packet: Packet) -> Result<(), Box<dyn Error + Send + Sync>> {
    let data = CliJoinServerReq::decode(packet.payload.as_slice());
    debug!("{:?}", data);
    Ok(())
}