//! Apply remote operations to local ECS state
//!
//! This module handles incoming EntityDelta messages and applies them to the
//! local Bevy world using CRDT merge semantics.

use std::collections::HashMap;

use bevy::prelude::*;
use uuid::Uuid;

use crate::{
    networking::{
        blob_support::{
            get_component_data,
            BlobStore,
        },
        delta_generation::NodeVectorClock,
        entity_map::NetworkEntityMap,
        merge::compare_operations_lww,
        messages::{
            ComponentData,
            EntityDelta,
            SyncMessage,
        },
        operations::ComponentOp,
        VectorClock,
    },
    persistence::reflection::deserialize_component_typed,
};

/// Resource to track the last vector clock and originating node for each component on each entity
///
/// This enables Last-Write-Wins conflict resolution by comparing incoming
/// operations' vector clocks with the current component's vector clock.
/// The node_id is used as a deterministic tiebreaker for concurrent operations.
#[derive(Resource, Default)]
pub struct ComponentVectorClocks {
    /// Maps (entity_network_id, component_type) -> (vector_clock, originating_node_id)
    clocks: HashMap<(Uuid, String), (VectorClock, Uuid)>,
}

impl ComponentVectorClocks {
    pub fn new() -> Self {
        Self {
            clocks: HashMap::new(),
        }
    }

    /// Get the current vector clock and node_id for a component
    pub fn get(&self, entity_id: Uuid, component_type: &str) -> Option<&(VectorClock, Uuid)> {
        self.clocks.get(&(entity_id, component_type.to_string()))
    }

    /// Update the vector clock and node_id for a component
    pub fn set(&mut self, entity_id: Uuid, component_type: String, clock: VectorClock, node_id: Uuid) {
        self.clocks.insert((entity_id, component_type), (clock, node_id));
    }

    /// Remove all clocks for an entity (when entity is deleted)
    pub fn remove_entity(&mut self, entity_id: Uuid) {
        self.clocks.retain(|(eid, _), _| *eid != entity_id);
    }
}

/// Apply an EntityDelta message to the local world
///
/// This function:
/// 1. Checks tombstone registry to prevent resurrection
/// 2. Looks up the entity by network_id
/// 3. Spawns a new entity if it doesn't exist
/// 4. Applies each ComponentOp using CRDT merge semantics
///
/// # Parameters
///
/// - `delta`: The EntityDelta to apply
/// - `world`: The Bevy world to apply changes to
pub fn apply_entity_delta(
    delta: &EntityDelta,
    world: &mut World,
) {
    // Validate and merge the remote vector clock
    {
        let mut node_clock = world.resource_mut::<NodeVectorClock>();

        // Check for clock regression (shouldn't happen in correct implementations)
        if delta.vector_clock.happened_before(&node_clock.clock) {
            warn!(
                "Received operation with clock from the past for entity {:?}. \
                 Remote clock happened before our clock. This may indicate clock issues.",
                delta.entity_id
            );
        }

        // Merge the remote vector clock into ours
        node_clock.clock.merge(&delta.vector_clock);
    }

    // Check if any operations are Delete operations
    for op in &delta.operations {
        if let crate::networking::ComponentOp::Delete { vector_clock } = op {
            // Record tombstone
            if let Some(mut registry) = world.get_resource_mut::<crate::networking::TombstoneRegistry>() {
                registry.record_deletion(
                    delta.entity_id,
                    delta.node_id,
                    vector_clock.clone(),
                );

                // Despawn the entity if it exists locally
                let entity_to_despawn = {
                    let entity_map = world.resource::<NetworkEntityMap>();
                    entity_map.get_entity(delta.entity_id)
                };
                if let Some(entity) = entity_to_despawn {
                    world.despawn(entity);
                    let mut entity_map = world.resource_mut::<NetworkEntityMap>();
                    entity_map.remove_by_network_id(delta.entity_id);
                    info!("Despawned entity {:?} due to Delete operation", delta.entity_id);
                }

                // Don't process other operations - entity is deleted
                return;
            }
        }
    }

    // Check if we should ignore this delta due to deletion
    if let Some(registry) = world.get_resource::<crate::networking::TombstoneRegistry>() {
        if registry.should_ignore_operation(delta.entity_id, &delta.vector_clock) {
            debug!(
                "Ignoring delta for deleted entity {:?}",
                delta.entity_id
            );
            return;
        }
    }

    let entity = {
        let entity_map = world.resource::<NetworkEntityMap>();
        if let Some(entity) = entity_map.get_entity(delta.entity_id) {
            entity
        } else {
            // Use shared helper to spawn networked entity with persistence
            crate::networking::spawn_networked_entity(world, delta.entity_id, delta.node_id)
        }
    };

    // Apply each operation (skip Delete operations - handled above)
    for op in &delta.operations {
        if !op.is_delete() {
            apply_component_op(entity, op, delta.node_id, world);
        }
    }

    // Trigger persistence by marking Persisted as changed
    // This ensures remote entities are persisted after sync
    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
        if let Some(mut persisted) = entity_mut.get_mut::<crate::persistence::Persisted>() {
            // Accessing &mut triggers Bevy's change detection
            let _ = &mut *persisted;
            debug!("Triggered persistence for synced entity {:?}", delta.entity_id);
        }
    }
}

/// Apply a single ComponentOp to an entity
///
/// This dispatches to the appropriate CRDT merge logic based on the operation
/// type.
fn apply_component_op(
    entity: Entity,
    op: &ComponentOp,
    incoming_node_id: Uuid,
    world: &mut World,
) {
    match op {
        | ComponentOp::Set {
            component_type,
            data,
            vector_clock,
        } => {
            apply_set_operation_with_lww(entity, component_type, data, vector_clock, incoming_node_id, world);
        }
        | ComponentOp::SetAdd { component_type, .. } => {
            // OR-Set add - Phase 10 provides OrSet<T> type
            // Application code should use OrSet in components and handle SetAdd/SetRemove
            // Full integration will be in Phase 12 plugin
            debug!("SetAdd operation for {} (use OrSet<T> in components)", component_type);
        }
        | ComponentOp::SetRemove { component_type, .. } => {
            // OR-Set remove - Phase 10 provides OrSet<T> type
            // Application code should use OrSet in components and handle SetAdd/SetRemove
            // Full integration will be in Phase 12 plugin
            debug!("SetRemove operation for {} (use OrSet<T> in components)", component_type);
        }
        | ComponentOp::SequenceInsert { .. } => {
            // RGA insert - will be implemented in Phase 11
            debug!("SequenceInsert operation not yet implemented");
        }
        | ComponentOp::SequenceDelete { .. } => {
            // RGA delete - will be implemented in Phase 11
            debug!("SequenceDelete operation not yet implemented");
        }
        | ComponentOp::Delete { .. } => {
            // Entity deletion - will be implemented in Phase 9
            debug!("Delete operation not yet implemented");
        }
    }
}

/// Apply a Set operation with Last-Write-Wins conflict resolution
///
/// Compares the incoming vector clock with the stored clock for this component.
/// Only applies the operation if the incoming clock wins the LWW comparison.
/// Uses node_id as a deterministic tiebreaker for concurrent operations.
fn apply_set_operation_with_lww(
    entity: Entity,
    component_type: &str,
    data: &ComponentData,
    incoming_clock: &VectorClock,
    incoming_node_id: Uuid,
    world: &mut World,
) {
    // Get the network ID for this entity
    let entity_network_id = {
        if let Ok(entity_ref) = world.get_entity(entity) {
            if let Some(networked) = entity_ref.get::<crate::networking::NetworkedEntity>() {
                networked.network_id
            } else {
                warn!("Entity {:?} has no NetworkedEntity component", entity);
                return;
            }
        } else {
            warn!("Entity {:?} not found", entity);
            return;
        }
    };

    // Check if we should apply this operation based on LWW
    let should_apply = {
        if let Some(component_clocks) = world.get_resource::<ComponentVectorClocks>() {
            if let Some((current_clock, current_node_id)) = component_clocks.get(entity_network_id, component_type) {
                // We have a current clock - do LWW comparison with real node IDs
                let decision = compare_operations_lww(
                    current_clock,
                    *current_node_id,
                    incoming_clock,
                    incoming_node_id,
                );

                match decision {
                    crate::networking::merge::MergeDecision::ApplyRemote => {
                        debug!(
                            "Applying remote Set for {} (remote is newer)",
                            component_type
                        );
                        true
                    }
                    crate::networking::merge::MergeDecision::KeepLocal => {
                        debug!(
                            "Ignoring remote Set for {} (local is newer)",
                            component_type
                        );
                        false
                    }
                    crate::networking::merge::MergeDecision::Concurrent => {
                        // For concurrent operations, use node_id comparison as deterministic tiebreaker
                        // This ensures all nodes make the same decision for concurrent updates
                        if incoming_node_id > *current_node_id {
                            debug!(
                                "Applying remote Set for {} (concurrent, remote node_id {:?} > local {:?})",
                                component_type, incoming_node_id, current_node_id
                            );
                            true
                        } else {
                            debug!(
                                "Ignoring remote Set for {} (concurrent, local node_id {:?} >= remote {:?})",
                                component_type, current_node_id, incoming_node_id
                            );
                            false
                        }
                    }
                    crate::networking::merge::MergeDecision::Equal => {
                        debug!("Ignoring remote Set for {} (clocks equal)", component_type);
                        false
                    }
                }
            } else {
                // No current clock - this is the first time we're setting this component
                debug!(
                    "Applying remote Set for {} (no current clock)",
                    component_type
                );
                true
            }
        } else {
            // No ComponentVectorClocks resource - apply unconditionally
            warn!("ComponentVectorClocks resource not found - applying Set without LWW check");
            true
        }
    };

    if !should_apply {
        return;
    }

    // Apply the operation
    apply_set_operation(entity, component_type, data, world);

    // Update the stored vector clock with node_id
    if let Some(mut component_clocks) = world.get_resource_mut::<ComponentVectorClocks>() {
        component_clocks.set(
            entity_network_id,
            component_type.to_string(),
            incoming_clock.clone(),
            incoming_node_id,
        );
        debug!(
            "Updated vector clock for {} on entity {:?} (node_id: {:?})",
            component_type, entity_network_id, incoming_node_id
        );
    }
}

/// Apply a Set operation (Last-Write-Wins)
///
/// Deserializes the component and inserts/updates it on the entity.
/// Handles both inline data and blob references.
fn apply_set_operation(
    entity: Entity,
    component_type: &str,
    data: &ComponentData,
    world: &mut World,
) {
    let type_registry = {
        let registry_resource = world.resource::<AppTypeRegistry>();
        registry_resource.read()
    };
    let blob_store = world.get_resource::<BlobStore>();
    // Get the actual data (resolve blob if needed)
    let data_bytes = match data {
        | ComponentData::Inline(bytes) => bytes.clone(),
        | ComponentData::BlobRef { hash: _, size: _ } => {
            if let Some(store) = blob_store {
                match get_component_data(data, store) {
                    Ok(bytes) => bytes,
                    Err(e) => {
                        error!(
                            "Failed to retrieve blob for component {}: {}",
                            component_type, e
                        );
                        return;
                    }
                }
            } else {
                error!(
                    "Blob reference for {} but no blob store available",
                    component_type
                );
                return;
            }
        }
    };

    let reflected = match deserialize_component_typed(&data_bytes, component_type, &type_registry) {
        Ok(reflected) => reflected,
        Err(e) => {
            error!("Failed to deserialize component {}: {}", component_type, e);
            return;
        }
    };

    let registration = match type_registry.get_with_type_path(component_type) {
        Some(reg) => reg,
        None => {
            error!("Component type {} not registered", component_type);
            return;
        }
    };

    let reflect_component = match registration.data::<ReflectComponent>() {
        Some(rc) => rc.clone(),
        None => {
            error!("Component type {} does not have ReflectComponent data", component_type);
            return;
        }
    };

    drop(type_registry);

    let type_registry_arc = world.resource::<AppTypeRegistry>().clone();
    let type_registry_guard = type_registry_arc.read();

    if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
        reflect_component.insert(&mut entity_mut, &*reflected, &type_registry_guard);
        debug!("Applied Set operation for {}", component_type);

        // If we just inserted a Transform component, also add NetworkedTransform
        // This ensures remote entities can have their Transform changes detected
        if component_type == "bevy_transform::components::transform::Transform" {
            if let Ok(mut entity_mut) = world.get_entity_mut(entity) {
                if entity_mut.get::<crate::networking::NetworkedTransform>().is_none() {
                    entity_mut.insert(crate::networking::NetworkedTransform::default());
                    debug!("Added NetworkedTransform to entity with Transform");
                }
            }
        }
    } else {
        error!("Entity {:?} not found when applying component {}", entity, component_type);
    }
}

/// System to receive and apply incoming EntityDelta messages
///
/// This system polls the GossipBridge for incoming messages and applies them
/// to the local world.
///
/// Add this to your app:
///
/// ```no_run
/// use bevy::prelude::*;
/// use lib::networking::receive_and_apply_deltas_system;
///
/// App::new()
///     .add_systems(Update, receive_and_apply_deltas_system);
/// ```
pub fn receive_and_apply_deltas_system(world: &mut World) {
    // Check if bridge exists
    if world.get_resource::<crate::networking::GossipBridge>().is_none() {
        return;
    }

    // Clone the bridge to avoid borrowing issues
    let bridge = world.resource::<crate::networking::GossipBridge>().clone();

    // Poll for incoming messages
    while let Some(message) = bridge.try_recv() {
        match message.message {
            | SyncMessage::EntityDelta {
                entity_id,
                node_id,
                vector_clock,
                operations,
            } => {
                let delta = EntityDelta {
                    entity_id,
                    node_id,
                    vector_clock,
                    operations,
                };

                debug!(
                    "Received EntityDelta for entity {:?} with {} operations",
                    delta.entity_id,
                    delta.operations.len()
                );

                apply_entity_delta(&delta, world);
            }
            | SyncMessage::JoinRequest { .. } => {
                // Handled by handle_join_requests_system
                debug!("JoinRequest handled by dedicated system");
            }
            | SyncMessage::FullState { .. } => {
                // Handled by handle_full_state_system
                debug!("FullState handled by dedicated system");
            }
            | SyncMessage::SyncRequest { .. } => {
                // Handled by handle_sync_requests_system
                debug!("SyncRequest handled by dedicated system");
            }
            | SyncMessage::MissingDeltas { .. } => {
                // Handled by handle_missing_deltas_system
                debug!("MissingDeltas handled by dedicated system");
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_node_clock_merge() {
        let node_id = uuid::Uuid::new_v4();
        let mut node_clock = NodeVectorClock::new(node_id);

        let remote_node = uuid::Uuid::new_v4();
        let mut remote_clock = crate::networking::VectorClock::new();
        remote_clock.increment(remote_node);
        remote_clock.increment(remote_node);

        // Merge remote clock
        node_clock.clock.merge(&remote_clock);

        // Our clock should have the remote node's sequence
        assert_eq!(node_clock.clock.get(remote_node), 2);
    }

    #[test]
    fn test_entity_delta_structure() {
        let entity_id = uuid::Uuid::new_v4();
        let node_id = uuid::Uuid::new_v4();
        let clock = crate::networking::VectorClock::new();

        let delta = EntityDelta::new(entity_id, node_id, clock, vec![]);

        assert_eq!(delta.entity_id, entity_id);
        assert_eq!(delta.node_id, node_id);
        assert_eq!(delta.operations.len(), 0);
    }
}