// src/transport/mod.rs

pub mod gift_wrap;
// Future: pub mod direct_encrypted;

use mostro_core::error::MostroError;
use nostr_sdk::prelude::*;

/// Transport-agnostic representation of an incoming message.
/// Replaces `nostr::nips::nip59::UnwrappedGift` throughout the codebase.
#[derive(Debug, Clone)]
pub struct IncomingMessage {
    /// Identity public key of the sender (master key).
    /// In NIP-59: this is `UnwrappedGift.sender`
    /// In NIP-04+NIP-44: this would be the event author
    pub sender: PublicKey,

    /// Trade public key used for this specific operation.
    /// In NIP-59: this is `UnwrappedGift.rumor.pubkey`
    /// In NIP-04+NIP-44: extracted from the signed message content
    pub trade_pubkey: PublicKey,

    /// Raw content string (JSON-serialized Message + optional Signature)
    pub content: String,

    /// When the message was created
    pub created_at: Timestamp,
}

/// Trait for pluggable messaging transports.
#[async_trait::async_trait]
pub trait MessageTransport: Send + Sync + 'static {
    /// Returns the Nostr event kind(s) this transport listens for.
    fn subscription_kinds(&self) -> Vec<Kind>;

    /// Attempt to extract a message from a raw Nostr event.
    /// Returns `None` if the event is not for this transport.
    async fn extract_message(
        &self,
        keys: &Keys,
        event: &Event,
    ) -> Result<Option<IncomingMessage>, MostroError>;

    /// Send an encrypted message to a recipient.
    async fn send_message(
        &self,
        sender_keys: &Keys,
        receiver: &PublicKey,
        payload: &str,
        expiration: Option<Timestamp>,
    ) -> Result<Event, MostroError>;
}

// src/transport/gift_wrap.rs

use super::{IncomingMessage, MessageTransport};
// ... imports ...

pub struct GiftWrapTransport;

#[async_trait::async_trait]
impl MessageTransport for GiftWrapTransport {
    fn subscription_kinds(&self) -> Vec<Kind> {
        vec![Kind::GiftWrap]
    }

    async fn extract_message(
        &self,
        keys: &Keys,
        event: &Event,
    ) -> Result<Option<IncomingMessage>, MostroError> {
        if event.kind != Kind::GiftWrap {
            return Ok(None);
        }

        if event.verify().is_err() {
            return Err(/* ... */);
        }

        let unwrapped = nip59::extract_rumor(keys, event).await
            .map_err(/* ... */)?;

        Ok(Some(IncomingMessage {
            sender: unwrapped.sender,
            trade_pubkey: unwrapped.rumor.pubkey,
            content: unwrapped.rumor.content,
            created_at: unwrapped.rumor.created_at,
        }))
    }

    async fn send_message(
        &self,
        sender_keys: &Keys,
        receiver: &PublicKey,
        payload: &str,
        expiration: Option<Timestamp>,
    ) -> Result<Event, MostroError> {
        // Current send_dm() logic moved here
        let content = /* ... build (Message, Option<Signature>) tuple ... */;
        let rumor = EventBuilder::text_note(content)
            .build(sender_keys.public_key());
        let mut tags = Vec::new();
        if let Some(ts) = expiration {
            tags.push(Tag::expiration(ts));
        }
        let event = EventBuilder::gift_wrap(
            sender_keys, receiver, rumor, Tags::from_list(tags)
        ).await?;
        Ok(event)
    }
}

// Before:
pub async fn send_dm(receiver_pubkey, sender_keys, payload, expiration) {
    // ... build rumor, gift_wrap, send ...
}

// After:
pub async fn send_dm(receiver_pubkey, sender_keys, payload, expiration) {
    let transport = get_transport(); // global or injected
    let event = transport.send_message(sender_keys, &receiver_pubkey, payload, expiration).await?;
    if let Ok(client) = get_nostr_client() {
        client.send_event(&event).await?;
    }
    Ok(())
}

// Before (app.rs:312-318):
if let Kind::GiftWrap = event.kind {
    if event.verify().is_err() { ... }
    let event = match nip59::extract_rumor(&my_keys, &event).await { ... };
    // ... timestamp check, content parsing, signature verification ...
}

// After:
let transport = get_transport();
if let Some(incoming) = transport.extract_message(&my_keys, &event).await? {
    // Timestamp validation
    if incoming.created_at.as_u64() < since_time { continue; }
    // Content parsing (identical logic, just reads from incoming.content)
    let (message, sig) = serde_json::from_str::<(Message, Option<Signature>)>(&incoming.content)?;
    // Signature verification using incoming.sender and incoming.trade_pubkey
    // ... rest of the logic identical but using incoming instead of event ...
}

// Before (main.rs:68-71):
let subscription = Filter::new()
    .pubkey(mostro_keys.public_key())
    .kind(Kind::GiftWrap)
    .limit(0);

// After:
let transport = get_transport();
let mut filter = Filter::new()
    .pubkey(mostro_keys.public_key())
    .limit(0);
for kind in transport.subscription_kinds() {
    filter = filter.kind(kind);
}
let subscription = filter;

let transport: Arc<dyn MessageTransport> = match config.transport.as_str() {
    "gift-wrap" => Arc::new(GiftWrapTransport),
    "direct-encrypted" => Arc::new(DirectEncryptedTransport),
    "dual" => Arc::new(DualTransport::new(
        GiftWrapTransport,
        DirectEncryptedTransport,
    )),
    _ => Arc::new(GiftWrapTransport), // default fallback
};

// Store globally (similar to NOSTR_CLIENT)
TRANSPORT.set(transport).expect("Transport already initialized");

// src/transport/direct_encrypted.rs

pub struct DirectEncryptedTransport;

#[async_trait::async_trait]
impl MessageTransport for DirectEncryptedTransport {
    fn subscription_kinds(&self) -> Vec<Kind> {
        vec![Kind::Custom(4)]
    }

    async fn extract_message(
        &self,
        keys: &Keys,
        event: &Event,
    ) -> Result<Option<IncomingMessage>, MostroError> {
        if event.kind != Kind::Custom(4) {
            return Ok(None);
        }

        // Decrypt content using NIP-44
        let decrypted = nip44::decrypt(
            keys.secret_key()?,
            &event.pubkey,
            &event.content,
        )?;

        // Parse the inner message structure
        // For direct encrypted, sender == event author
        // trade_pubkey is extracted from the signed message content
        let (message, sig): (Message, Option<Signature>) =
            serde_json::from_str(&decrypted)?;

        // Trade pubkey: if signature present, it was signed by trade key
        // otherwise trade_pubkey == sender
        let trade_pubkey = if let Some(sig) = &sig {
            // Extract trade pubkey from message verification
            // (trade key signs the message, identity key wraps the event)
            extract_trade_pubkey_from_sig(&message, sig)?
        } else {
            event.pubkey  // Full privacy mode: identity == trade
        };

        Ok(Some(IncomingMessage {
            sender: event.pubkey,
            trade_pubkey,
            content: decrypted,
            created_at: event.created_at,
        }))
    }

    async fn send_message(
        &self,
        sender_keys: &Keys,
        receiver: &PublicKey,
        payload: &str,
        expiration: Option<Timestamp>,
    ) -> Result<Event, MostroError> {
        // Encrypt with NIP-44
        let encrypted = nip44::encrypt(
            sender_keys.secret_key()?,
            receiver,
            payload,
            nip44::Version::V2,
        )?;

        let mut tags = vec![Tag::public_key(*receiver)];
        if let Some(ts) = expiration {
            tags.push(Tag::expiration(ts));
        }

        let event = EventBuilder::new(Kind::Custom(4), encrypted)
            .tags(Tags::from_list(tags))
            .sign_with_keys(sender_keys)?;

        Ok(event)
    }
}

// src/transport/dual.rs

pub struct DualTransport {
    gift_wrap: GiftWrapTransport,
    direct: DirectEncryptedTransport,
}

#[async_trait::async_trait]
impl MessageTransport for DualTransport {
    fn subscription_kinds(&self) -> Vec<Kind> {
        let mut kinds = self.gift_wrap.subscription_kinds();
        kinds.extend(self.direct.subscription_kinds());
        kinds
    }

    async fn extract_message(&self, keys: &Keys, event: &Event)
        -> Result<Option<IncomingMessage>, MostroError>
    {
        // Try gift wrap first, then direct encrypted
        if let Some(msg) = self.gift_wrap.extract_message(keys, event).await? {
            return Ok(Some(msg));
        }
        self.direct.extract_message(keys, event).await
    }

    async fn send_message(&self, /* ... */) -> Result<Event, MostroError> {
        // Send using the preferred/configured outbound transport
        // Could be configurable: "send as gift_wrap" or "send as direct"
        self.gift_wrap.send_message(/* ... */).await
    }
}

// src/config/settings.rs — add dynamic POW adjustment

pub struct DynamicPow {
    base_pow: u8,
    current_pow: AtomicU8,
    failed_decrypts_per_minute: AtomicU64,
    last_reset: AtomicU64,
}

impl DynamicPow {
    /// If failed decrypt rate exceeds threshold, auto-increase POW
    pub fn check_and_adjust(&self) {
        let rate = self.failed_decrypts_per_minute.load(Ordering::Relaxed);
        if rate > 100 {
            let new_pow = (self.current_pow.load(Ordering::Relaxed) + 2).min(32);
            self.current_pow.store(new_pow, Ordering::Relaxed);
            tracing::warn!("🚨 Spam detected: {} failed decrypts/min, POW raised to {}", rate, new_pow);
        }
    }
}

// Already partially handled by Nostr SDK, but add application-level dedup
use probabilistic_collections::bloom::BloomFilter;

pub struct EventDedup {
    filter: RwLock<BloomFilter<EventId>>,
    count: AtomicU64,
}

pub struct CircuitBreaker {
    state: AtomicU8, // 0=closed, 1=open, 2=half-open
    failure_count: AtomicU64,
    threshold: u64,
    cooldown_secs: u64,
}