//! # @ruvector/edge-net
//!
//! Distributed compute intelligence network for browser-based compute contribution.
//! Earn **rUv** (Resource Utility Vouchers) by sharing idle compute.
//!
//! ## Overview
//!
//! edge-net enables websites to participate in a P2P compute marketplace where:
//! - Contributors donate idle CPU cycles via Web Workers
//! - Tasks are distributed across the network
//! - rUv (Resource Utility Vouchers) earned based on contribution
//! - Early adopter multipliers up to 10x
//! - rUv spent to access the network's compute power
//!
//! ## Quick Start
//!
//! ```html
//! <script type="module">
//!   import { EdgeNet } from '@ruvector/edge-net';
//!
//!   const node = await EdgeNet.init({
//!     siteId: 'my-site',
//!     contribution: 0.3,  // 30% CPU when idle
//!   });
//!
//!   console.log(`Balance: ${node.creditBalance()} rUv`);
//! </script>
//! ```
//!
//! ## Features
//!
//! - Self-learning adaptive security
//! - Genesis node sunset when network matures
//! - Lifecycle events and celebrations
//! - Adversarial testing framework
//! - Network evolution and self-organization
//! - Sustainable economic model

use wasm_bindgen::prelude::*;

pub mod identity;
pub mod credits;
pub mod tasks;
pub mod network;
pub mod scheduler;
pub mod security;
pub mod events;
pub mod adversarial;
pub mod evolution;
pub mod tribute;
pub mod pikey;
pub mod learning;
pub mod rac;
pub mod mcp;
pub mod swarm;
pub mod capabilities;
pub mod compute;
pub mod ai;

use identity::WasmNodeIdentity;
use learning::NetworkLearning;
use rac::CoherenceEngine;
use credits::{WasmCreditLedger, ContributionCurve};
use tasks::{WasmTaskExecutor, WasmTaskQueue};
use scheduler::WasmIdleDetector;
use events::NetworkEvents;
use adversarial::AdversarialSimulator;
use evolution::{EconomicEngine, EvolutionEngine, NetworkTopology, OptimizationEngine};
use tribute::{FoundingRegistry, ContributionStream};
pub use capabilities::WasmCapabilities;

/// Initialize panic hook for better error messages in console
#[wasm_bindgen(start)]
pub fn init_panic_hook() {
    #[cfg(feature = "console_error_panic_hook")]
    console_error_panic_hook::set_once();
}

/// Main EdgeNet node - the entry point for participating in the network
#[wasm_bindgen]
pub struct EdgeNetNode {
    identity: WasmNodeIdentity,
    ledger: WasmCreditLedger,
    executor: WasmTaskExecutor,
    queue: WasmTaskQueue,
    idle_detector: WasmIdleDetector,
    config: NodeConfig,
    stats: NodeStats,
    /// Lifecycle events and celebrations
    events: NetworkEvents,
    /// Adversarial testing (for security validation)
    adversarial: AdversarialSimulator,
    /// Economic sustainability engine
    economics: EconomicEngine,
    /// Network evolution engine
    evolution: EvolutionEngine,
    /// Topology self-organization
    topology: NetworkTopology,
    /// Task optimization engine
    optimization: OptimizationEngine,
    /// Founding contributor registry
    founding: FoundingRegistry,
    /// Contribution streams
    streams: ContributionStream,
    /// Network learning intelligence
    learning: NetworkLearning,
    /// Adversarial coherence engine (RAC)
    coherence: CoherenceEngine,
    /// Exotic AI capabilities (Time Crystal, NAO, MicroLoRA, HDC, etc.)
    capabilities: WasmCapabilities,
}

#[wasm_bindgen]
#[derive(Clone, Default)]
pub struct NodeConfig {
    /// Maximum CPU usage when idle (0.0 - 1.0)
    pub cpu_limit: f32,
    /// Maximum memory usage in bytes
    pub memory_limit: usize,
    /// Maximum bandwidth in bytes/sec
    pub bandwidth_limit: usize,
    /// Minimum idle time before contributing (ms)
    pub min_idle_time: u32,
    /// Whether to reduce contribution on battery
    pub respect_battery: bool,
}

#[wasm_bindgen]
#[derive(Clone, Default)]
pub struct NodeStats {
    /// Total rUv (Resource Utility Vouchers) earned
    pub ruv_earned: u64,
    /// Total rUv spent
    pub ruv_spent: u64,
    /// Tasks completed
    pub tasks_completed: u64,
    /// Tasks submitted
    pub tasks_submitted: u64,
    /// Total uptime in seconds
    pub uptime_seconds: u64,
    /// Current reputation score (0.0 - 1.0)
    pub reputation: f32,
    /// Current contribution multiplier
    pub multiplier: f32,
    /// Active lifecycle events
    pub celebration_boost: f32,
}

#[wasm_bindgen]
impl EdgeNetNode {
    /// Create a new EdgeNet node
    #[wasm_bindgen(constructor)]
    pub fn new(site_id: &str, config: Option<NodeConfig>) -> Result<EdgeNetNode, JsValue> {
        let config = config.unwrap_or_default();

        // Generate or restore identity
        let identity = WasmNodeIdentity::generate(site_id)?;

        // Initialize credit ledger
        let ledger = WasmCreditLedger::new(identity.node_id())?;

        // Initialize task executor
        let executor = WasmTaskExecutor::new(config.memory_limit)?;

        // Initialize task queue
        let queue = WasmTaskQueue::new()?;

        // Initialize idle detector
        let idle_detector = WasmIdleDetector::new(
            config.cpu_limit,
            config.min_idle_time,
        )?;

        // Initialize economic and evolution engines
        let mut topology = NetworkTopology::new();
        topology.register_node(&identity.node_id(), &[1.0, 0.5, 0.3]);

        let node_id = identity.node_id();
        Ok(EdgeNetNode {
            identity,
            ledger,
            executor,
            queue,
            idle_detector,
            config,
            stats: NodeStats::default(),
            events: NetworkEvents::new(),
            adversarial: AdversarialSimulator::new(),
            economics: EconomicEngine::new(),
            evolution: EvolutionEngine::new(),
            topology,
            optimization: OptimizationEngine::new(),
            founding: FoundingRegistry::new(),
            streams: ContributionStream::new(),
            learning: NetworkLearning::new(),
            coherence: CoherenceEngine::new(),
            capabilities: WasmCapabilities::new(&node_id),
        })
    }

    /// Get the node's unique identifier
    #[wasm_bindgen(js_name = nodeId)]
    pub fn node_id(&self) -> String {
        self.identity.node_id()
    }

    /// Get current rUv (Resource Utility Voucher) balance
    #[wasm_bindgen(js_name = creditBalance)]
    pub fn credit_balance(&self) -> u64 {
        self.ledger.balance()
    }

    /// Alias for creditBalance - returns rUv balance
    #[wasm_bindgen(js_name = ruvBalance)]
    pub fn ruv_balance(&self) -> u64 {
        self.ledger.balance()
    }

    /// Get current contribution multiplier based on network size
    #[wasm_bindgen(js_name = getMultiplier)]
    pub fn get_multiplier(&self) -> f32 {
        let base = ContributionCurve::current_multiplier(self.ledger.network_compute());
        let celebration = self.stats.celebration_boost;
        base * celebration.max(1.0)
    }

    /// Check for active celebration events
    #[wasm_bindgen(js_name = checkEvents)]
    pub fn check_events(&mut self) -> String {
        let events_json = self.events.check_active_events();
        self.stats.celebration_boost = self.events.get_celebration_boost();
        events_json
    }

    /// Get motivational message (subtle Easter egg)
    #[wasm_bindgen(js_name = getMotivation)]
    pub fn get_motivation(&self) -> String {
        self.events.get_motivation(self.ledger.balance())
    }

    /// Run security audit (adversarial testing)
    #[wasm_bindgen(js_name = runSecurityAudit)]
    pub fn run_security_audit(&mut self) -> String {
        self.adversarial.run_security_audit()
    }

    /// Get themed network status
    #[wasm_bindgen(js_name = getThemedStatus)]
    pub fn get_themed_status(&self, node_count: u32) -> String {
        self.events.get_themed_status(node_count, self.ledger.total_earned())
    }

    /// Get node statistics
    #[wasm_bindgen(js_name = getStats)]
    pub fn get_stats(&self) -> NodeStats {
        self.stats.clone()
    }

    /// Check if user is currently idle
    #[wasm_bindgen(js_name = isIdle)]
    pub fn is_idle(&self) -> bool {
        self.idle_detector.is_idle()
    }

    /// Get current throttle level (0.0 - 1.0)
    #[wasm_bindgen(js_name = getThrottle)]
    pub fn get_throttle(&self) -> f32 {
        self.idle_detector.get_throttle()
    }

    /// Submit a task to the network
    #[wasm_bindgen(js_name = submitTask)]
    pub async fn submit_task(
        &mut self,
        task_type: &str,
        payload: &[u8],
        max_credits: u64,
    ) -> Result<JsValue, JsValue> {
        // Check balance
        if self.ledger.balance() < max_credits {
            return Err(JsValue::from_str("Insufficient credits"));
        }

        // Create task
        let task = self.queue.create_task(
            task_type,
            payload,
            max_credits,
            &self.identity,
        )?;

        // Submit to network
        let result = self.queue.submit(task).await?;

        // Deduct credits
        self.ledger.deduct(result.cost)?;
        self.stats.tasks_submitted += 1;
        self.stats.ruv_spent += result.cost;

        Ok(result.into())
    }

    /// Process the next available task (called by worker)
    #[wasm_bindgen(js_name = processNextTask)]
    pub async fn process_next_task(&mut self) -> Result<bool, JsValue> {
        // Check if we should be working
        if !self.idle_detector.should_work() {
            return Ok(false);
        }

        // Claim next task
        let task = match self.queue.claim_next(&self.identity).await? {
            Some(t) => t,
            None => return Ok(false),
        };

        // Execute task
        let result = self.executor.execute(&task).await?;

        // Save task info before moving
        let task_id = task.id.clone();
        let base_reward = task.base_reward;

        // Submit result
        self.queue.complete(task_id.clone(), result, &self.identity).await?;

        // Earn credits (with multiplier)
        let multiplier = self.get_multiplier();
        let credits = (base_reward as f32 * multiplier) as u64;
        self.ledger.credit(credits, &format!("task:{}", task_id))?;

        self.stats.tasks_completed += 1;
        self.stats.ruv_earned += credits;

        // Check for milestone achievements
        let _ = self.events.check_milestones(self.ledger.balance(), &self.identity.node_id());

        Ok(true)
    }

    /// Start contributing to the network
    #[wasm_bindgen]
    pub fn start(&mut self) -> Result<(), JsValue> {
        self.idle_detector.start()?;
        Ok(())
    }

    /// Pause contribution
    #[wasm_bindgen]
    pub fn pause(&mut self) {
        self.idle_detector.pause();
    }

    /// Resume contribution
    #[wasm_bindgen]
    pub fn resume(&mut self) {
        self.idle_detector.resume();
    }

    /// Disconnect from the network
    #[wasm_bindgen]
    pub fn disconnect(&mut self) -> Result<(), JsValue> {
        self.queue.disconnect()?;
        self.idle_detector.stop();
        Ok(())
    }

    // ========== Network Evolution & Sustainability ==========

    /// Check if network is self-sustaining
    #[wasm_bindgen(js_name = isSelfSustaining)]
    pub fn is_self_sustaining(&self, active_nodes: u32, daily_tasks: u64) -> bool {
        self.economics.is_self_sustaining(active_nodes, daily_tasks)
    }

    /// Get economic health metrics
    #[wasm_bindgen(js_name = getEconomicHealth)]
    pub fn get_economic_health(&self) -> String {
        let health = self.economics.get_health();
        format!(
            r#"{{"velocity":{:.3},"utilization":{:.3},"growth":{:.3},"stability":{:.3}}}"#,
            health.velocity, health.utilization, health.growth_rate, health.stability
        )
    }

    /// Get network fitness score (0-1)
    #[wasm_bindgen(js_name = getNetworkFitness)]
    pub fn get_network_fitness(&self) -> f32 {
        self.evolution.get_network_fitness()
    }

    /// Check if this node should replicate (high performer)
    #[wasm_bindgen(js_name = shouldReplicate)]
    pub fn should_replicate(&self) -> bool {
        self.evolution.should_replicate(&self.identity.node_id())
    }

    /// Get recommended configuration for new nodes
    #[wasm_bindgen(js_name = getRecommendedConfig)]
    pub fn get_recommended_config(&self) -> String {
        self.evolution.get_recommended_config()
    }

    /// Get optimal peers for task routing
    #[wasm_bindgen(js_name = getOptimalPeers)]
    pub fn get_optimal_peers(&self, count: usize) -> Vec<String> {
        self.topology.get_optimal_peers(&self.identity.node_id(), count)
    }

    /// Get optimization statistics
    #[wasm_bindgen(js_name = getOptimizationStats)]
    pub fn get_optimization_stats(&self) -> String {
        self.optimization.get_stats()
    }

    /// Get protocol development fund balance
    #[wasm_bindgen(js_name = getProtocolFund)]
    pub fn get_protocol_fund(&self) -> u64 {
        self.economics.get_protocol_fund()
    }

    /// Get treasury balance for operations
    #[wasm_bindgen(js_name = getTreasury)]
    pub fn get_treasury(&self) -> u64 {
        self.economics.get_treasury()
    }

    /// Process epoch for economic distribution
    #[wasm_bindgen(js_name = processEpoch)]
    pub fn process_epoch(&mut self) {
        self.economics.advance_epoch();
        self.evolution.evolve();
    }

    /// Record peer interaction for topology optimization
    #[wasm_bindgen(js_name = recordPeerInteraction)]
    pub fn record_peer_interaction(&mut self, peer_id: &str, success_rate: f32) {
        self.topology.update_connection(&self.identity.node_id(), peer_id, success_rate);
    }

    /// Record task routing outcome for optimization
    #[wasm_bindgen(js_name = recordTaskRouting)]
    pub fn record_task_routing(&mut self, task_type: &str, node_id: &str, latency_ms: u64, success: bool) {
        self.optimization.record_routing(task_type, node_id, latency_ms, success);
    }

    /// Record node performance for evolution
    #[wasm_bindgen(js_name = recordPerformance)]
    pub fn record_performance(&mut self, success_rate: f32, throughput: f32) {
        self.evolution.record_performance(&self.identity.node_id(), success_rate, throughput);
    }

    /// Get contribution stream health
    #[wasm_bindgen(js_name = isStreamHealthy)]
    pub fn is_stream_healthy(&self) -> bool {
        self.streams.is_healthy()
    }

    /// Get founding contributor count
    #[wasm_bindgen(js_name = getFounderCount)]
    pub fn get_founder_count(&self) -> usize {
        self.founding.get_founder_count()
    }

    // ========================================================================
    // Learning Intelligence Methods
    // ========================================================================

    /// Record a task execution trajectory for learning
    #[wasm_bindgen(js_name = recordLearningTrajectory)]
    pub fn record_learning_trajectory(&self, trajectory_json: &str) -> bool {
        self.learning.record_trajectory(trajectory_json)
    }

    /// Store a learned pattern in the reasoning bank
    #[wasm_bindgen(js_name = storePattern)]
    pub fn store_pattern(&self, pattern_json: &str) -> i32 {
        self.learning.store_pattern(pattern_json)
    }

    /// Lookup similar patterns for task optimization
    #[wasm_bindgen(js_name = lookupPatterns)]
    pub fn lookup_patterns(&self, query_json: &str, k: usize) -> String {
        self.learning.lookup_patterns(query_json, k)
    }

    /// Get learning statistics
    #[wasm_bindgen(js_name = getLearningStats)]
    pub fn get_learning_stats(&self) -> String {
        self.learning.get_stats()
    }

    /// Get energy efficiency ratio from spike-driven attention
    #[wasm_bindgen(js_name = getEnergyEfficiency)]
    pub fn get_energy_efficiency(&self, seq_len: usize, hidden_dim: usize) -> f32 {
        self.learning.get_energy_ratio(seq_len, hidden_dim)
    }

    /// Prune low-quality learned patterns
    #[wasm_bindgen(js_name = prunePatterns)]
    pub fn prune_patterns(&self, min_usage: usize, min_confidence: f64) -> usize {
        self.learning.prune(min_usage, min_confidence)
    }

    /// Get trajectory count for learning analysis
    #[wasm_bindgen(js_name = getTrajectoryCount)]
    pub fn get_trajectory_count(&self) -> usize {
        self.learning.trajectory_count()
    }

    /// Get stored pattern count
    #[wasm_bindgen(js_name = getPatternCount)]
    pub fn get_pattern_count(&self) -> usize {
        self.learning.pattern_count()
    }

    // ========================================================================
    // RAC Adversarial Coherence Methods (12 Axioms)
    // ========================================================================

    /// Get coherence engine event count
    #[wasm_bindgen(js_name = getCoherenceEventCount)]
    pub fn get_coherence_event_count(&self) -> usize {
        self.coherence.event_count()
    }

    /// Get current Merkle root for audit (Axiom 11: Equivocation detectable)
    #[wasm_bindgen(js_name = getMerkleRoot)]
    pub fn get_merkle_root(&self) -> String {
        self.coherence.get_merkle_root()
    }

    /// Get quarantined claim count (Axiom 9: Quarantine is mandatory)
    #[wasm_bindgen(js_name = getQuarantinedCount)]
    pub fn get_quarantined_count(&self) -> usize {
        self.coherence.quarantined_count()
    }

    /// Get active conflict count (Axiom 6: Disagreement is signal)
    #[wasm_bindgen(js_name = getConflictCount)]
    pub fn get_conflict_count(&self) -> usize {
        self.coherence.conflict_count()
    }

    /// Get coherence statistics
    #[wasm_bindgen(js_name = getCoherenceStats)]
    pub fn get_coherence_stats(&self) -> String {
        self.coherence.get_stats()
    }

    /// Check if a claim can be used (not quarantined)
    #[wasm_bindgen(js_name = canUseClaim)]
    pub fn can_use_claim(&self, claim_id: &str) -> bool {
        self.coherence.can_use_claim(claim_id)
    }

    /// Get quarantine level for a claim
    #[wasm_bindgen(js_name = getClaimQuarantineLevel)]
    pub fn get_claim_quarantine_level(&self, claim_id: &str) -> u8 {
        self.coherence.get_quarantine_level(claim_id)
    }

    // ========================================================================
    // Exotic AI Capabilities Methods
    // ========================================================================

    /// Get all available exotic capabilities and their status
    #[wasm_bindgen(js_name = getCapabilities)]
    pub fn get_capabilities(&self) -> JsValue {
        self.capabilities.get_capabilities()
    }

    /// Get capabilities summary as JSON
    #[wasm_bindgen(js_name = getCapabilitiesSummary)]
    pub fn get_capabilities_summary(&self) -> JsValue {
        self.capabilities.get_summary()
    }

    /// Enable Time Crystal for P2P synchronization
    #[wasm_bindgen(js_name = enableTimeCrystal)]
    pub fn enable_time_crystal(&mut self, oscillators: usize) -> bool {
        self.capabilities.enable_time_crystal(oscillators, 100)
    }

    /// Get Time Crystal synchronization level (0.0 - 1.0)
    #[wasm_bindgen(js_name = getTimeCrystalSync)]
    pub fn get_time_crystal_sync(&self) -> f32 {
        self.capabilities.get_time_crystal_sync()
    }

    /// Enable Neural Autonomous Organization for governance
    #[wasm_bindgen(js_name = enableNAO)]
    pub fn enable_nao(&mut self, quorum: f32) -> bool {
        self.capabilities.enable_nao(quorum)
    }

    /// Propose an action in the NAO
    #[wasm_bindgen(js_name = proposeNAO)]
    pub fn propose_nao(&mut self, action: &str) -> String {
        self.capabilities.propose_nao(action)
    }

    /// Vote on a NAO proposal
    #[wasm_bindgen(js_name = voteNAO)]
    pub fn vote_nao(&mut self, proposal_id: &str, weight: f32) -> bool {
        self.capabilities.vote_nao(proposal_id, weight)
    }

    /// Enable MicroLoRA for self-learning
    #[wasm_bindgen(js_name = enableMicroLoRA)]
    pub fn enable_micro_lora(&mut self, rank: usize) -> bool {
        self.capabilities.enable_micro_lora(128, rank)
    }

    /// Enable HDC for hyperdimensional computing
    #[wasm_bindgen(js_name = enableHDC)]
    pub fn enable_hdc(&mut self) -> bool {
        self.capabilities.enable_hdc()
    }

    /// Enable WTA for instant decisions
    #[wasm_bindgen(js_name = enableWTA)]
    pub fn enable_wta(&mut self, num_neurons: usize) -> bool {
        self.capabilities.enable_wta(num_neurons, 0.5, 0.8)
    }

    /// Enable Global Workspace for attention
    #[wasm_bindgen(js_name = enableGlobalWorkspace)]
    pub fn enable_global_workspace(&mut self, capacity: usize) -> bool {
        self.capabilities.enable_global_workspace(capacity)
    }

    /// Enable BTSP for one-shot learning
    #[wasm_bindgen(js_name = enableBTSP)]
    pub fn enable_btsp(&mut self, input_dim: usize) -> bool {
        self.capabilities.enable_btsp(input_dim, 2000.0)
    }

    /// Enable Morphogenetic Network for emergent topology
    #[wasm_bindgen(js_name = enableMorphogenetic)]
    pub fn enable_morphogenetic(&mut self, size: i32) -> bool {
        self.capabilities.enable_morphogenetic(size, size)
    }

    /// Step all exotic capabilities forward
    #[wasm_bindgen(js_name = stepCapabilities)]
    pub fn step_capabilities(&mut self, dt: f32) {
        self.capabilities.step(dt);
    }
}

/// Configuration builder for EdgeNet
#[wasm_bindgen]
pub struct EdgeNetConfig {
    site_id: String,
    cpu_limit: f32,
    memory_limit: usize,
    bandwidth_limit: usize,
    min_idle_time: u32,
    respect_battery: bool,
    allowed_tasks: Vec<String>,
    relay_urls: Vec<String>,
}

#[wasm_bindgen]
impl EdgeNetConfig {
    #[wasm_bindgen(constructor)]
    pub fn new(site_id: &str) -> EdgeNetConfig {
        EdgeNetConfig {
            site_id: site_id.to_string(),
            cpu_limit: 0.3,
            memory_limit: 256 * 1024 * 1024, // 256MB
            bandwidth_limit: 1024 * 1024,     // 1MB/s
            min_idle_time: 5000,              // 5s
            respect_battery: true,
            allowed_tasks: vec![
                "vectors".to_string(),
                "embeddings".to_string(),
                "encryption".to_string(),
            ],
            relay_urls: vec![
                "https://gun-manhattan.herokuapp.com/gun".to_string(),
            ],
        }
    }

    #[wasm_bindgen(js_name = cpuLimit)]
    pub fn cpu_limit(mut self, limit: f32) -> EdgeNetConfig {
        self.cpu_limit = limit.clamp(0.0, 1.0);
        self
    }

    #[wasm_bindgen(js_name = memoryLimit)]
    pub fn memory_limit(mut self, bytes: usize) -> EdgeNetConfig {
        self.memory_limit = bytes;
        self
    }

    #[wasm_bindgen(js_name = minIdleTime)]
    pub fn min_idle_time(mut self, ms: u32) -> EdgeNetConfig {
        self.min_idle_time = ms;
        self
    }

    #[wasm_bindgen(js_name = respectBattery)]
    pub fn respect_battery(mut self, respect: bool) -> EdgeNetConfig {
        self.respect_battery = respect;
        self
    }

    #[wasm_bindgen(js_name = addRelay)]
    pub fn add_relay(mut self, url: &str) -> EdgeNetConfig {
        self.relay_urls.push(url.to_string());
        self
    }

    #[wasm_bindgen]
    pub fn build(self) -> Result<EdgeNetNode, JsValue> {
        let config = NodeConfig {
            cpu_limit: self.cpu_limit,
            memory_limit: self.memory_limit,
            bandwidth_limit: self.bandwidth_limit,
            min_idle_time: self.min_idle_time,
            respect_battery: self.respect_battery,
        };

        EdgeNetNode::new(&self.site_id, Some(config))
    }
}

#[cfg(all(test, feature = "bench"))]
mod bench;

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

    #[test]
    fn test_config_builder() {
        let config = EdgeNetConfig::new("test-site")
            .cpu_limit(0.5)
            .memory_limit(512 * 1024 * 1024)
            .min_idle_time(10000);

        assert_eq!(config.cpu_limit, 0.5);
        assert_eq!(config.memory_limit, 512 * 1024 * 1024);
        assert_eq!(config.min_idle_time, 10000);
    }
}