use crate::character_client::CharacterClient;
use crate::connection_service::ConnectionService;
use crate::packet::{send_packet, Packet, PacketPayload};
use crate::packet_type::PacketType;
use crate::world_client::WorldClientManager;
use chrono::{Local, Timelike};
use std::error::Error;
use std::sync::Arc;
use tokio::net::TcpStream;
use tokio::sync::Mutex;
use tonic::transport::Channel;
use tracing::{debug, error, info, warn};
use utils::service_discovery::get_kube_service_endpoints_by_dns;
use crate::world_client::world::WorldObject;

fn distance(x1: f64, y1: f64, x2: f64, y2: f64) -> u16 {
    let dist = ((x2 - x1).powi(2) + (y2 - y1).powi(2)).sqrt();
    dist.round() as u16
}

pub(crate) async fn handle_change_map_req(
    packet: Packet,
    character_client: Arc<Mutex<CharacterClient>>,
    connection_service: Arc<ConnectionService>,
    connection_id: String,
    world_client_manager: Arc<WorldClientManager>,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    use crate::packets::cli_change_map_req::*;
    use crate::packets::srv_change_map_reply::*;
    let request = CliChangeMapReq::decode(packet.payload.as_slice())?;
    debug!("{:?}", request);

    let mut user_id = "".to_string();
    let mut char_id = 0;
    let mut client_id = 0;
    let mut character_id_list: Vec<u32> = Vec::new();
    let session_id;
    if let Some(mut state) = connection_service.get_connection(&connection_id) {
        user_id = state.user_id.expect("Missing user id in connection state");
        session_id = state.session_id.expect("Missing session id in connection state");
        char_id = state.character_id.expect("Missing character id in connection state");
        character_id_list = state.character_list.clone().expect("Missing character id list");
        client_id = state.client_id;
    }

    let mut character_client = character_client.lock().await;
    let character_data = character_client
        .get_character(&user_id.to_string(), character_id_list[char_id as usize] as u8)
        .await?;

    let character = character_data.character.unwrap_or_default();
    let stats = character.stats.unwrap();

    let now = Local::now();
    let time_as_u16 = (now.hour() * 100 + now.minute()) as u16;

    // if let Err(e) = world_client_manager
    //     .send_client_map_change_event(&*session_id, request.map_id as u32)
    //     .await
    // {
    //     warn!("Failed to send map change event to world service: {}", e);
    //     // Don't return error as the map change itself was successful
    // }
    // 
    // debug!("Sent map change event for client {} to world service: map {}", session_id, request.map_id);

    let data = SrvChangeMapReply {
        object_index: client_id,
        hp: stats.hp as u16,
        mp: stats.mp as u16,
        xp: stats.xp as u16,
        penalize_xp: stats.penalty_xp as u16,
        craft_rate: 0,
        update_time: 0,
        world_rate: 1,
        town_rate: 1,
        item_rate: [0u8; 11],
        flags: 1,
        world_time: time_as_u16,
        team_number: 10,
    };
    let response_packet = Packet::new(PacketType::PakwcChangeMapReply, &data)?;
    if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
        let writer_clone = state.writer.clone().unwrap();
        let mut locked_stream = writer_clone.lock().await;
        send_packet(&mut locked_stream, &response_packet).await?;
    }

    Ok(())
}

pub(crate) async fn handle_mouse_cmd_req(
    packet: Packet,
    connection_service: Arc<ConnectionService>,
    connection_id: String,
    world_client_manager: Arc<WorldClientManager>,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    use crate::packets::cli_mouse_cmd::*;
    use crate::packets::srv_mouse_cmd::*;
    let request = CliMouseCmd::decode(packet.payload.as_slice())?;
    debug!("{:?}", request);

    let mut char_id = 0;
    let mut client_id = 0;
    let mut character_id_list: Vec<u32> = Vec::new();
    let mut session_id = "".to_string();
    if let Some(mut state) = connection_service.get_connection(&connection_id) {
        char_id = state.character_id.expect("Missing character id in connection state");
        character_id_list = state.character_list.clone().expect("Missing character id list");
        client_id = state.client_id;
        session_id = state.session_id.clone().expect("Missing session id in connection state");
    }

    if let Err(e) = world_client_manager
        .send_client_move_event(&*session_id, request.x, request.y, request.z as f32)
        .await
    {
        error!("Failed to send move event to world service: {}", e);
        return Err(e);
    }

    debug!("Sent move event for client {} to world service: ({}, {}, {})",
                   session_id, request.x, request.y, request.z);

    let data = SrvMouseCmd {
        id: client_id,
        target_id: request.target_id,
        distance: distance(520000 as f64, 520000 as f64, request.x as f64, request.y as f64),
        x: request.x,
        y: request.y,
        z: request.z,
    };
    let response_packet = Packet::new(PacketType::PakwcMouseCmd, &data)?;
    if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
        let writer_clone = state.writer.clone().unwrap();
        let mut locked_stream = writer_clone.lock().await;
        send_packet(&mut locked_stream, &response_packet).await?;
    }
    Ok(())
}

// World service integration - movement events

pub(crate) async fn handle_toggle_move_req(
    packet: Packet,
    connection_service: Arc<ConnectionService>,
    connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    use crate::packets::cli_toggle_move::*;
    use crate::packets::srv_toggle_move::*;
    let request = CliToggleMove::decode(packet.payload.as_slice())?;
    debug!("{:?}", request);

    let mut client_id = 0;
    if let Some(mut state) = connection_service.get_connection(&connection_id) {
        client_id = state.client_id;
    }
    let mut toggle_type = 0;;
    {
        use crate::packets::cli_toggle_move::ToggleMove;
        match request.type_ {
            ToggleMove::Run => { toggle_type = 2; }
            ToggleMove::Sit => { toggle_type = 8; }
            ToggleMove::Drive => { toggle_type = 9; }
        }
    }

    use crate::packets::srv_toggle_move::ToggleMove;
    let mut final_type = ToggleMove::Run;
    {
        match toggle_type {
            0 => { final_type = ToggleMove::Run; }
            1 => { final_type = ToggleMove::Sit; }
            2 => { final_type = ToggleMove::Drive; }
            _ => { final_type = ToggleMove::Run; }
        }
    }

    let data = SrvToggleMove {
        object_id: client_id,
        type_: final_type,
        run_speed: 0,
    };
    let response_packet = Packet::new(PacketType::PakwcToggleMove, &data)?;
    if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
        let writer_clone = state.writer.clone().unwrap();
        let mut locked_stream = writer_clone.lock().await;
        send_packet(&mut locked_stream, &response_packet).await?;
    }
    Ok(())
}

pub(crate) async fn handle_set_animation_req(
    packet: Packet,
    connection_service: Arc<ConnectionService>,
    connection_id: String,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    use crate::packets::cli_set_animation::*;
    use crate::packets::srv_set_animation::*;
    let request = CliSetAnimation::decode(packet.payload.as_slice())?;
    debug!("{:?}", request);

    let mut client_id = 0;
    if let Some(mut state) = connection_service.get_connection(&connection_id) {
        client_id = state.client_id;
    }

    let data = SrvSetAnimation {
        id: request.id,
        value: request.value,
        object_id: client_id,
    };
    let response_packet = Packet::new(PacketType::PacwcSetAnimation, &data)?;
    if let Some(mut state) = connection_service.get_connection_mut(&connection_id) {
        let writer_clone = state.writer.clone().unwrap();
        let mut locked_stream = writer_clone.lock().await;
        send_packet(&mut locked_stream, &response_packet).await?;
    }
    Ok(())
}

// World service integration - movement events

pub(crate) async fn spawn_mob(
    mob: &WorldObject,
    connection_service: Arc<ConnectionService>,
    session_id: String
) -> Result<(), Box<dyn Error + Send + Sync>> {
    use crate::packets::srv_mob_char::SrvMobChar;

    let data = SrvMobChar {
        id: mob.id as u16,
        x: mob.x,
        y: mob.y,
        dest_x: 0.0,
        dest_y: 0.0,
        command: 0,
        target_id: 0,
        move_mode: 0,
        hp: mob.hp,
        team_id: 0,
        status_flag: 0,
        npc_id: mob.id as u16,
        quest_id: 0,
    };
    let response_packet = Packet::new(PacketType::PakwcMobChar, &data)?;
    if let Some(mut state) = connection_service.get_connection_mut(&session_id) {
        let writer_clone = state.writer.clone().unwrap();
        let mut locked_stream = writer_clone.lock().await;
        send_packet(&mut locked_stream, &response_packet).await?;
    }
    Ok(())
}

pub(crate) async fn spawn_mobs(
    mobs: Vec<&WorldObject>,
    connection_service: Arc<ConnectionService>,
    session_id: String
) {
    for mob in mobs {
        let result = spawn_mob(mob, connection_service.clone(), session_id.clone()).await;
        if let Err(e) = result {
            error!("Failed to spawn mob for session {}: {}", session_id, e);
        }
    }
}

async fn handle_world_events(
    world_client_manager: Arc<WorldClientManager>,
    connection_service: Arc<ConnectionService>,
    session_id: String,
) {
    info!("Starting world event handler for session {}", session_id);

    loop {
        match world_client_manager.receive_world_event(&session_id).await {
            Some(world_event) => {
                // debug!("Received world event for session {}: {:?}", session_id, world_event);

                // Process the world event and convert to game packets
                match world_event.event {
                    Some(crate::world_client::world::world_event::Event::NpcSpawn(npc_spawn)) => {
                        debug!("Processing NPC spawn event: {:?}", npc_spawn);
                        // Convert to the appropriate game packet and send to client
                        let npc = WorldObject {
                            id: npc_spawn.id,
                            object_type: 2,
                            x: npc_spawn.pos_x,
                            y: npc_spawn.pos_y,
                            z: 0.0,
                            map_id: 0,
                            name: "NPC".to_string(),
                            hp: npc_spawn.hp,
                            max_hp: npc_spawn.hp,
                        };
                        // if let Err(e) = spawn_npc(&npc, connection_service.clone(), session_id.clone()).await {
                        //     error!("Failed to spawn npc for session {}: {}", session_id, e);
                        // }
                    }
                    Some(crate::world_client::world::world_event::Event::MobSpawn(mob_spawn)) => {
                        debug!("Processing mob spawn event: {:?}", mob_spawn);
                        // Convert to the appropriate game packet and send to client
                        let mob = WorldObject {
                            id: mob_spawn.id,
                            object_type: 3,
                            x: mob_spawn.pos_x,
                            y: mob_spawn.pos_y,
                            z: 0.0,
                            map_id: 0,
                            name: "Mob".to_string(),
                            hp: mob_spawn.hp,
                            max_hp: mob_spawn.hp,
                        };
                        if let Err(e) = spawn_mob(&mob, connection_service.clone(), session_id.clone()).await {
                            error!("Failed to spawn mob for session {}: {}", session_id, e);
                        }
                    }
                    Some(crate::world_client::world::world_event::Event::ObjectDespawn(despawn)) => {
                        debug!("Processing object despawn event: {:?}", despawn);
                        // Convert to the appropriate game packet and send to client
                    }
                    Some(crate::world_client::world::world_event::Event::NearbyUpdate(nearby_update)) => {
                        debug!("Processing nearby objects update: {} objects", nearby_update.objects.len());
                        // Convert to the appropriate game packet and send to client

                        let npcs = nearby_update.objects.iter().filter(|obj| obj.object_type == 2).collect::<Vec<_>>();
                        let mobs = nearby_update.objects.iter().filter(|obj| obj.object_type == 3).collect::<Vec<_>>();

                        debug!("There are {} npcs and {} mobs", npcs.len(), mobs.len());
                        debug!("Nearby npcs: {:?}", npcs);
                        debug!("Nearby mobs: {:?}", mobs);

                        // if !npcs.is_empty() {
                        //     spawn_npcs(npcs, connection_service.clone(), session_id.clone()).await;
                        // }

                        if !mobs.is_empty() {
                            spawn_mobs(mobs, connection_service.clone(), session_id.clone()).await;
                        }

                        // if !npcs.is_empty() {
                        //     // Send all nearby npcs in a single batch update
                        //     let batch_event = SrvNpcChar {
                        //         id: 0,
                        //         x: 0.0,
                        //         y: 0.0,
                        //         dest_x: 0.0,
                        //         dest_y: 0.0,
                        //         command: 0,
                        //         target_id: 0,
                        //         move_mode: 0,
                        //         hp: 0,
                        //         team_id: 0,
                        //         status_flag: 0,
                        //         npc_id: 0,
                        //         quest_id: 0,
                        //         angle: 0.0,
                        //         event_status: 0,
                        //     };
                        //     let response_packet = Packet::new(PacketType::PakwcNpcChar, &batch_event)?;
                        //     if let Some(mut state) = connection_service.get_connection_mut(&session_id) {
                        //         let writer_clone = state.writer.clone().unwrap();
                        //         let mut locked_stream = writer_clone.lock().await;
                        //         send_packet(&mut locked_stream, &response_packet).await?;
                        //     }
                        // }
                    }
                    None => {
                        warn!("Received world event with no event data for session {}", session_id);
                    }
                }
            }
            None => {
                debug!("World event stream ended for session {}", session_id);
                break;
            }
        }
    }

    info!("World event handler ended for session {}", session_id);
}

// Helper function to start world event handling for a client
pub fn start_world_event_handler(
    world_client_manager: Arc<WorldClientManager>,
    connection_service: Arc<ConnectionService>,
    session_id: String,
) {
    tokio::spawn(async move {
        handle_world_events(world_client_manager, connection_service, session_id).await;
    });
}