use proc_macro::TokenStream;
use quote::quote;
use syn::{
    DeriveInput,
    ItemStruct,
    parse_macro_input,
};

/// Sync strategy types
#[derive(Debug, Clone, PartialEq)]
enum SyncStrategy {
    LastWriteWins,
    Set,
    Sequence,
    Custom,
}

impl SyncStrategy {
    fn from_str(s: &str) -> Result<Self, String> {
        match s {
            | "LastWriteWins" => Ok(SyncStrategy::LastWriteWins),
            | "Set" => Ok(SyncStrategy::Set),
            | "Sequence" => Ok(SyncStrategy::Sequence),
            | "Custom" => Ok(SyncStrategy::Custom),
            | _ => Err(format!(
                "Unknown strategy '{}'. Choose one of: \"LastWriteWins\", \"Set\", \"Sequence\", \"Custom\"",
                s
            )),
        }
    }

    fn to_tokens(&self) -> proc_macro2::TokenStream {
        match self {
            | SyncStrategy::LastWriteWins => {
                quote! { libmarathon::networking::SyncStrategy::LastWriteWins }
            },
            | SyncStrategy::Set => quote! { libmarathon::networking::SyncStrategy::Set },
            | SyncStrategy::Sequence => quote! { libmarathon::networking::SyncStrategy::Sequence },
            | SyncStrategy::Custom => quote! { libmarathon::networking::SyncStrategy::Custom },
        }
    }
}

/// Parsed sync attributes
struct SyncAttributes {
    version: u32,
    strategy: SyncStrategy,
}

impl SyncAttributes {
    fn parse(input: &DeriveInput) -> Result<Self, syn::Error> {
        let mut version: Option<u32> = None;
        let mut strategy: Option<SyncStrategy> = None;

        // Find the #[sync(...)] attribute
        for attr in &input.attrs {
            if !attr.path().is_ident("sync") {
                continue;
            }

            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("version") {
                    let value: syn::LitInt = meta.value()?.parse()?;
                    version = Some(value.base10_parse()?);
                    Ok(())
                } else if meta.path.is_ident("strategy") {
                    let value: syn::LitStr = meta.value()?.parse()?;
                    let strategy_str = value.value();
                    strategy = Some(
                        SyncStrategy::from_str(&strategy_str)
                            .map_err(|e| syn::Error::new_spanned(&value, e))?,
                    );
                    Ok(())
                } else {
                    Err(meta.error("unrecognized sync attribute"))
                }
            })?;
        }

        // Require version and strategy
        let version = version.ok_or_else(|| {
            syn::Error::new(
                proc_macro2::Span::call_site(),
                "Missing required attribute `version`\n\n                 \n\n                 = help: Add #[sync(version = 1, strategy = \"...\")] to your struct\n\n                 = note: See documentation: https://docs.rs/lonni/sync/strategies.html",
            )
        })?;

        let strategy = strategy.ok_or_else(|| {
            syn::Error::new(
                proc_macro2::Span::call_site(),
                "Missing required attribute `strategy`\n\n                 \n\n                 = help: Choose one of: \"LastWriteWins\", \"Set\", \"Sequence\", \"Custom\"\n\n                 = help: Add #[sync(version = 1, strategy = \"LastWriteWins\")] to your struct\n\n                 = note: See documentation: https://docs.rs/lonni/sync/strategies.html",
            )
        })?;

        Ok(SyncAttributes {
            version,
            strategy,
        })
    }
}

/// RFC 0003 macro: Generate SyncComponent trait implementation
///
/// # Example
/// ```ignore
/// use bevy::prelude::*;
/// use libmarathon::networking::Synced;
/// use sync_macros::Synced as SyncedDerive;
///
/// #[derive(Component, Clone)]
/// #[derive(Synced)]
/// #[sync(version = 1, strategy = "LastWriteWins")]
/// struct Health(f32);
///
/// // In a Bevy system:
/// fn spawn_health(mut commands: Commands) {
///     commands.spawn((Health(100.0), Synced));
/// }
/// ```
#[proc_macro_derive(Synced, attributes(sync))]
pub fn derive_synced(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    // Parse attributes
    let attrs = match SyncAttributes::parse(&input) {
        | Ok(attrs) => attrs,
        | Err(e) => return TokenStream::from(e.to_compile_error()),
    };

    let name = &input.ident;
    let name_str = name.to_string();
    let version = attrs.version;
    let strategy_tokens = attrs.strategy.to_tokens();

    // Generate serialization method based on type
    let serialize_impl = generate_serialize(&input);
    let deserialize_impl = generate_deserialize(&input, name);

    // Generate merge method based on strategy
    let merge_impl = generate_merge(&input, &attrs.strategy);

    // Extract struct attributes and visibility for re-emission
    let vis = &input.vis;
    let attrs_without_sync: Vec<_> = input
        .attrs
        .iter()
        .filter(|attr| !attr.path().is_ident("sync"))
        .collect();
    let struct_token = match &input.data {
        | syn::Data::Struct(_) => quote! { struct },
        | _ => quote! {},
    };

    // Re-emit the struct with rkyv derives added
    let rkyv_struct = match &input.data {
        | syn::Data::Struct(data_struct) => {
            let fields = &data_struct.fields;
            quote! {
                #[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
                #(#attrs_without_sync)*
                #vis #struct_token #name #fields
            }
        },
        | _ => quote! {},
    };

    let expanded = quote! {
        // Re-emit struct with rkyv derives
        #rkyv_struct

        // Register component with inventory for type registry
        // Build type path at compile time using concat! and module_path!
        // since std::any::type_name() is not yet const
        const _: () = {
            const TYPE_PATH: &str = concat!(module_path!(), "::", stringify!(#name));

            inventory::submit! {
                libmarathon::persistence::ComponentMeta {
                    type_name: #name_str,
                    type_path: TYPE_PATH,
                    type_id: std::any::TypeId::of::<#name>(),
                deserialize_fn: |bytes: &[u8]| -> anyhow::Result<Box<dyn std::any::Any>> {
                    let component: #name = rkyv::from_bytes::<#name, rkyv::rancor::Failure>(bytes)?;
                    Ok(Box::new(component))
                },
                serialize_fn: |world: &bevy::ecs::world::World, entity: bevy::ecs::entity::Entity| -> Option<Vec<u8>> {
                    world.get::<#name>(entity).and_then(|component| {
                        rkyv::to_bytes::<rkyv::rancor::Failure>(component)
                            .map(|bytes| bytes.to_vec())
                            .ok()
                    })
                },
                insert_fn: |entity_mut: &mut bevy::ecs::world::EntityWorldMut, boxed: Box<dyn std::any::Any>| {
                    if let Ok(component) = boxed.downcast::<#name>() {
                        entity_mut.insert(*component);
                    }
                },
            }
            };
        };

        impl libmarathon::networking::SyncComponent for #name {
            const VERSION: u32 = #version;
            const STRATEGY: libmarathon::networking::SyncStrategy = #strategy_tokens;

            #[inline]
            fn serialize_sync(&self) -> anyhow::Result<Vec<u8>> {
                #serialize_impl
            }

            #[inline]
            fn deserialize_sync(data: &[u8]) -> anyhow::Result<Self> {
                #deserialize_impl
            }

            #[inline]
            fn merge(&mut self, remote: Self, clock_cmp: libmarathon::networking::ClockComparison) -> libmarathon::networking::ComponentMergeDecision {
                #merge_impl
            }
        }
    };

    TokenStream::from(expanded)
}

/// Generate specialized serialization code
fn generate_serialize(_input: &DeriveInput) -> proc_macro2::TokenStream {
    // Use rkyv for zero-copy serialization
    // Later we can optimize for specific types (e.g., f32 -> to_le_bytes)
    quote! {
        rkyv::to_bytes::<rkyv::rancor::Failure>(self).map(|bytes| bytes.to_vec()).map_err(|e| anyhow::anyhow!("Serialization failed: {}", e))
    }
}

/// Generate specialized deserialization code
fn generate_deserialize(_input: &DeriveInput, _name: &syn::Ident) -> proc_macro2::TokenStream {
    quote! {
        rkyv::from_bytes::<Self, rkyv::rancor::Failure>(data).map_err(|e| anyhow::anyhow!("Deserialization failed: {}", e))
    }
}

/// Generate merge logic based on strategy
fn generate_merge(input: &DeriveInput, strategy: &SyncStrategy) -> proc_macro2::TokenStream {
    match strategy {
        | SyncStrategy::LastWriteWins => generate_lww_merge(input),
        | SyncStrategy::Set => generate_set_merge(input),
        | SyncStrategy::Sequence => generate_sequence_merge(input),
        | SyncStrategy::Custom => generate_custom_merge(input),
    }
}

/// Generate hash calculation code for tiebreaking in concurrent merges
///
/// Returns a TokenStream that computes hashes for both local and remote values
/// and compares them for deterministic conflict resolution.
fn generate_hash_tiebreaker() -> proc_macro2::TokenStream {
    quote! {
        let local_hash = {
            let bytes = rkyv::to_bytes::<rkyv::rancor::Failure>(self).map(|b| b.to_vec()).unwrap_or_default();
            bytes.iter().fold(0u64, |acc, &b| acc.wrapping_mul(31).wrapping_add(b as u64))
        };
        let remote_hash = {
            let bytes = rkyv::to_bytes::<rkyv::rancor::Failure>(&remote).map(|b| b.to_vec()).unwrap_or_default();
            bytes.iter().fold(0u64, |acc, &b| acc.wrapping_mul(31).wrapping_add(b as u64))
        };
    }
}

/// Generate Last-Write-Wins merge logic
fn generate_lww_merge(_input: &DeriveInput) -> proc_macro2::TokenStream {
    let hash_tiebreaker = generate_hash_tiebreaker();

    quote! {
        use tracing::info;

        match clock_cmp {
            libmarathon::networking::ClockComparison::RemoteNewer => {
                info!(
                    component = std::any::type_name::<Self>(),
                    ?clock_cmp,
                    "Taking remote (newer)"
                );
                *self = remote;
                libmarathon::networking::ComponentMergeDecision::TookRemote
            }
            libmarathon::networking::ClockComparison::LocalNewer => {
                libmarathon::networking::ComponentMergeDecision::KeptLocal
            }
            libmarathon::networking::ClockComparison::Concurrent => {
                // Tiebreaker: Compare serialized representations for deterministic choice
                // In a real implementation, we'd use node_id, but for now use a simple hash
                #hash_tiebreaker

                if remote_hash > local_hash {
                    info!(
                        component = std::any::type_name::<Self>(),
                        ?clock_cmp,
                        "Taking remote (concurrent, tiebreaker)"
                    );
                    *self = remote;
                    libmarathon::networking::ComponentMergeDecision::TookRemote
                } else {
                    libmarathon::networking::ComponentMergeDecision::KeptLocal
                }
            }
        }
    }
}

/// Generate OR-Set merge logic
///
/// For OR-Set strategy, the component must contain an OrSet<T> field.
/// We merge by calling the OrSet's merge method which implements add-wins
/// semantics.
fn generate_set_merge(_input: &DeriveInput) -> proc_macro2::TokenStream {
    let hash_tiebreaker = generate_hash_tiebreaker();

    quote! {
        use tracing::info;

        // For Set strategy, we always merge the sets
        // The OrSet CRDT handles the conflict resolution with add-wins semantics
        info!(
            component = std::any::type_name::<Self>(),
            "Merging OR-Set (add-wins semantics)"
        );

        // Assuming the component wraps an OrSet or has a field with merge()
        // For now, we'll do a structural merge by replacing the whole value
        // This is a simplified implementation - full implementation would require
        // the component to expose merge() method or implement it directly

        match clock_cmp {
            libmarathon::networking::ClockComparison::RemoteNewer => {
                *self = remote;
                libmarathon::networking::ComponentMergeDecision::TookRemote
            }
            libmarathon::networking::ClockComparison::LocalNewer => {
                libmarathon::networking::ComponentMergeDecision::KeptLocal
            }
            libmarathon::networking::ClockComparison::Concurrent => {
                // In a full implementation, we would merge the OrSet here
                // For now, use LWW with tiebreaker as fallback
                #hash_tiebreaker

                if remote_hash > local_hash {
                    *self = remote;
                    libmarathon::networking::ComponentMergeDecision::TookRemote
                } else {
                    libmarathon::networking::ComponentMergeDecision::KeptLocal
                }
            }
        }
    }
}

/// Generate RGA/Sequence merge logic
///
/// For Sequence strategy, the component must contain an Rga<T> field.
/// We merge by calling the Rga's merge method which maintains causal ordering.
fn generate_sequence_merge(_input: &DeriveInput) -> proc_macro2::TokenStream {
    let hash_tiebreaker = generate_hash_tiebreaker();

    quote! {
        use tracing::info;

        // For Sequence strategy, we always merge the sequences
        // The RGA CRDT handles the conflict resolution with causal ordering
        info!(
            component = std::any::type_name::<Self>(),
            "Merging RGA sequence (causal ordering)"
        );

        // Assuming the component wraps an Rga or has a field with merge()
        // For now, we'll do a structural merge by replacing the whole value
        // This is a simplified implementation - full implementation would require
        // the component to expose merge() method or implement it directly

        match clock_cmp {
            libmarathon::networking::ClockComparison::RemoteNewer => {
                *self = remote;
                libmarathon::networking::ComponentMergeDecision::TookRemote
            }
            libmarathon::networking::ClockComparison::LocalNewer => {
                libmarathon::networking::ComponentMergeDecision::KeptLocal
            }
            libmarathon::networking::ClockComparison::Concurrent => {
                // In a full implementation, we would merge the Rga here
                // For now, use LWW with tiebreaker as fallback
                #hash_tiebreaker

                if remote_hash > local_hash {
                    *self = remote;
                    libmarathon::networking::ComponentMergeDecision::TookRemote
                } else {
                    libmarathon::networking::ComponentMergeDecision::KeptLocal
                }
            }
        }
    }
}

/// Generate custom merge logic placeholder
fn generate_custom_merge(input: &DeriveInput) -> proc_macro2::TokenStream {
    let name = &input.ident;
    quote! {
        compile_error!(
            concat!(
                "Custom strategy requires implementing ConflictResolver trait for ",
                stringify!(#name)
            )
        );
        libmarathon::networking::ComponentMergeDecision::KeptLocal
    }
}


/// Attribute macro for synced components
///
/// This is an alternative to the derive macro that automatically adds rkyv derives.
///
/// # Example
/// ```ignore
/// #[synced(version = 1, strategy = "LastWriteWins")]
/// struct Health(f32);
/// ```
#[proc_macro_attribute]
pub fn synced(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input_struct = match syn::parse::<ItemStruct>(item.clone()) {
        Ok(s) => s,
        Err(e) => {
            return syn::Error::new_spanned(
                proc_macro2::TokenStream::from(item),
                format!("synced attribute can only be applied to structs: {}", e),
            )
            .to_compile_error()
            .into();
        }
    };

    // Parse the attribute arguments manually
    let attr_str = attr.to_string();
    let (version, strategy) = parse_attr_string(&attr_str);

    // Generate the same implementations as the derive macro
    let name = &input_struct.ident;
    let name_str = name.to_string();
    let strategy_tokens = strategy.to_tokens();
    let vis = &input_struct.vis;
    let attrs = &input_struct.attrs;
    let generics = &input_struct.generics;
    let fields = &input_struct.fields;

    // Convert ItemStruct to DeriveInput for compatibility with existing functions
    // Build it manually to avoid parse_quote issues with tuple structs
    let derive_input = DeriveInput {
        attrs: attrs.clone(),
        vis: vis.clone(),
        ident: name.clone(),
        generics: generics.clone(),
        data: syn::Data::Struct(syn::DataStruct {
            struct_token: syn::token::Struct::default(),
            fields: fields.clone(),
            semi_token: if matches!(fields, syn::Fields::Unit) {
                Some(syn::token::Semi::default())
            } else {
                None
            },
        }),
    };

    let serialize_impl = generate_serialize(&derive_input);
    let deserialize_impl = generate_deserialize(&derive_input, name);
    let merge_impl = generate_merge(&derive_input, &strategy);

    // Add semicolon for tuple/unit structs
    let semi = if matches!(fields, syn::Fields::Named(_)) {
        quote! {}
    } else {
        quote! { ; }
    };

    let expanded = quote! {
        // Output the struct with rkyv derives added
        #[derive(rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)]
        #(#attrs)*
        #vis struct #name #generics #fields #semi

        // Register component with inventory for type registry
        const _: () = {
            const TYPE_PATH: &str = concat!(module_path!(), "::", stringify!(#name));

            inventory::submit! {
                libmarathon::persistence::ComponentMeta {
                    type_name: #name_str,
                    type_path: TYPE_PATH,
                    type_id: std::any::TypeId::of::<#name>(),
                    deserialize_fn: |bytes: &[u8]| -> anyhow::Result<Box<dyn std::any::Any>> {
                        let component: #name = rkyv::from_bytes::<#name, rkyv::rancor::Failure>(bytes)?;
                        Ok(Box::new(component))
                    },
                    serialize_fn: |world: &bevy::ecs::world::World, entity: bevy::ecs::entity::Entity| -> Option<Vec<u8>> {
                        world.get::<#name>(entity).and_then(|component| {
                            rkyv::to_bytes::<rkyv::rancor::Failure>(component)
                                .map(|bytes| bytes.to_vec())
                                .ok()
                        })
                    },
                    insert_fn: |entity_mut: &mut bevy::ecs::world::EntityWorldMut, boxed: Box<dyn std::any::Any>| {
                        if let Ok(component) = boxed.downcast::<#name>() {
                            entity_mut.insert(*component);
                        }
                    },
                }
            };
        };

        impl libmarathon::networking::SyncComponent for #name {
            const VERSION: u32 = #version;
            const STRATEGY: libmarathon::networking::SyncStrategy = #strategy_tokens;

            #[inline]
            fn serialize_sync(&self) -> anyhow::Result<Vec<u8>> {
                #serialize_impl
            }

            #[inline]
            fn deserialize_sync(data: &[u8]) -> anyhow::Result<Self> {
                #deserialize_impl
            }

            #[inline]
            fn merge(&mut self, remote: Self, clock_cmp: libmarathon::networking::ClockComparison) -> libmarathon::networking::ComponentMergeDecision {
                #merge_impl
            }
        }
    };

    TokenStream::from(expanded)
}

/// Parse attribute string (simple parser for version and strategy)
fn parse_attr_string(attr: &str) -> (u32, SyncStrategy) {
    let mut version = 1;
    let mut strategy = SyncStrategy::LastWriteWins;
    
    // Simple parsing - look for version = N and strategy = "..."
    if let Some(v_pos) = attr.find("version") {
        if let Some(eq_pos) = attr[v_pos..].find('=') {
            let start = v_pos + eq_pos + 1;
            let rest = &attr[start..].trim();
            if let Some(comma_pos) = rest.find(',') {
                if let Ok(v) = rest[..comma_pos].trim().parse() {
                    version = v;
                }
            } else if let Ok(v) = rest.trim().parse() {
                version = v;
            }
        }
    }
    
    if let Some(s_pos) = attr.find("strategy") {
        if let Some(eq_pos) = attr[s_pos..].find('=') {
            let start = s_pos + eq_pos + 1;
            let rest = &attr[start..].trim();
            if let Some(quote_start) = rest.find('"') {
                if let Some(quote_end) = rest[quote_start + 1..].find('"') {
                    let strategy_str = &rest[quote_start + 1..quote_start + 1 + quote_end];
                    if let Ok(s) = SyncStrategy::from_str(strategy_str) {
                        strategy = s;
                    }
                }
            }
        }
    }
    
    (version, strategy)
}