optirs-core 0.3.1

// Secure Multi-Party Computation (SMPC) for Privacy-Preserving Optimization
//
// This module implements advanced cryptographic protocols for secure multi-party
// computation, enabling privacy-preserving federated optimization without relying
// solely on differential privacy noise.

use crate::error::{OptimError, Result};
use scirs2_core::ndarray::Array1;
use scirs2_core::numeric::Float;
use scirs2_core::random::Rng;
use std::collections::HashMap;
use std::fmt::Debug;

/// Secure Multi-Party Computation coordinator
pub struct SMPCCoordinator<T: Float + Debug + Send + Sync + 'static> {
    /// Configuration for SMPC protocols
    config: SMPCConfig,

    /// Shamir secret sharing engine
    secret_sharing: ShamirSecretSharing<T>,

    /// Secure aggregation with cryptographic guarantees
    secure_aggregator: CryptographicAggregator<T>,

    /// Homomorphic encryption engine
    homomorphic_engine: HomomorphicEngine<T>,

    /// Zero-knowledge proof system
    zk_proof_system: ZKProofSystem<T>,

    /// Participant management
    participants: HashMap<String, Participant>,

    /// Current protocol state
    protocol_state: SMPCProtocolState,
}

/// Configuration for SMPC protocols
#[derive(Debug, Clone)]
pub struct SMPCConfig {
    /// Number of participants
    pub num_participants: usize,

    /// Threshold for secret sharing (k in k-out-of-n)
    pub threshold: usize,

    /// Security parameter for cryptographic operations
    pub security_parameter: usize,

    /// Enable homomorphic encryption
    pub enable_homomorphic: bool,

    /// Enable zero-knowledge proofs
    pub enable_zk_proofs: bool,

    /// SMPC protocol variant
    pub protocol_variant: SMPCProtocol,

    /// Communication security level
    pub communication_security: CommunicationSecurity,

    /// Malicious adversary tolerance
    pub malicious_tolerance: MaliciousTolerance,
}

/// SMPC protocol variants
#[derive(Debug, Clone, Copy)]
pub enum SMPCProtocol {
    /// BGW protocol for arithmetic circuits
    BGW,

    /// GMW protocol for boolean circuits
    GMW,

    /// SPDZ protocol with preprocessing
    SPDZ,

    /// ABY hybrid protocol
    ABY,

    /// Custom protocol for federated learning
    FederatedSMPC,
}

/// Communication security models
#[derive(Debug, Clone, Copy)]
pub enum CommunicationSecurity {
    /// Semi-honest adversaries
    SemiHonest,

    /// Malicious adversaries with abort
    MaliciousAbort,

    /// Malicious adversaries with guaranteed output
    MaliciousGuaranteed,
}

/// Malicious adversary tolerance configuration
#[derive(Debug, Clone)]
pub struct MaliciousTolerance {
    /// Maximum number of corrupted participants
    pub max_corrupted: usize,

    /// Enable Byzantine fault tolerance
    pub byzantine_tolerance: bool,

    /// Verification threshold
    pub verification_threshold: f64,

    /// Enable commit-and-prove protocols
    pub commit_and_prove: bool,
}

/// Participant in SMPC protocol
#[derive(Debug, Clone)]
pub struct Participant {
    /// Unique participant identifier
    pub id: String,

    /// Public key for the participant
    pub public_key: Vec<u8>,

    /// Participation status
    pub status: ParticipantStatus,

    /// Trust score for malicious detection
    pub trust_score: f64,

    /// Commitment to computation
    pub commitment: Option<Vec<u8>>,
}

/// Participant status in protocol
#[derive(Debug, Clone, Copy)]
pub enum ParticipantStatus {
    /// Active and participating
    Active,

    /// Temporarily unavailable
    Unavailable,

    /// Suspected malicious behavior
    Suspicious,

    /// Confirmed malicious behavior
    Malicious,
}

/// SMPC protocol execution state
#[derive(Debug, Clone)]
pub enum SMPCProtocolState {
    /// Initialization phase
    Initialization,

    /// Key generation and setup
    Setup,

    /// Input sharing phase
    InputSharing,

    /// Computation phase
    Computation,

    /// Output reconstruction
    OutputReconstruction,

    /// Protocol completed
    Completed,

    /// Protocol aborted due to malicious behavior
    Aborted(String),
}

/// Shamir Secret Sharing implementation
pub struct ShamirSecretSharing<T: Float + Debug + Send + Sync + 'static> {
    /// Threshold for reconstruction
    threshold: usize,

    /// Number of shares
    num_shares: usize,

    /// Prime field for arithmetic
    prime_field: u128,

    /// Polynomial coefficients
    coefficients: Vec<T>,
}

impl<T: Float + Debug + Send + Sync + 'static> ShamirSecretSharing<T> {
    /// Create new secret sharing instance
    pub fn new(threshold: usize, numshares: usize) -> Self {
        // Use a large prime for field arithmetic
        let prime_field = 2u128.pow(127) - 1; // Mersenne prime

        Self {
            threshold,
            num_shares: numshares,
            prime_field,
            coefficients: Vec::new(),
        }
    }

    /// Share a secret value
    pub fn share_secret(&mut self, secret: T) -> Result<Vec<(usize, T)>> {
        // Generate random polynomial coefficients
        let mut rng = scirs2_core::random::Random::seed(42);
        self.coefficients.clear();
        self.coefficients.push(secret); // a0 = secret

        for _ in 1..self.threshold {
            let coeff = T::from(rng.gen_range(0.0..1.0)).expect("unwrap failed");
            self.coefficients.push(coeff);
        }

        // Evaluate polynomial at different points
        let mut shares = Vec::new();
        for i in 1..=self.num_shares {
            let x = T::from(i).unwrap_or_else(|| T::zero());
            let y = self.evaluate_polynomial(x);
            shares.push((i, y));
        }

        Ok(shares)
    }

    /// Reconstruct secret from shares
    pub fn reconstruct_secret(&self, shares: &[(usize, T)]) -> Result<T> {
        if shares.len() < self.threshold {
            return Err(OptimError::InvalidConfig(
                "Insufficient shares for reconstruction".to_string(),
            ));
        }

        // Use Lagrange interpolation
        let mut result = T::zero();

        for (i, &(xi, yi)) in shares.iter().enumerate().take(self.threshold) {
            let mut lagrange_coeff = T::one();

            for (j, &(xj, _)) in shares.iter().enumerate().take(self.threshold) {
                if i != j {
                    let xi_f = T::from(xi).unwrap_or_else(|| T::zero());
                    let xj_f = T::from(xj).unwrap_or_else(|| T::zero());
                    lagrange_coeff = lagrange_coeff * (T::zero() - xj_f) / (xi_f - xj_f);
                }
            }

            result = result + yi * lagrange_coeff;
        }

        Ok(result)
    }

    /// Evaluate polynomial at given point
    fn evaluate_polynomial(&self, x: T) -> T {
        let mut result = T::zero();
        let mut x_power = T::one();

        for &coeff in &self.coefficients {
            result = result + coeff * x_power;
            x_power = x_power * x;
        }

        result
    }
}

/// Cryptographic aggregator with formal security guarantees
pub struct CryptographicAggregator<T: Float + Debug + Send + Sync + 'static> {
    /// Configuration
    config: SMPCConfig,

    /// Commitment scheme
    commitment_scheme: CommitmentScheme<T>,

    /// Verification parameters
    verification_params: VerificationParameters<T>,

    /// Aggregation proofs
    aggregation_proofs: Vec<AggregationProof<T>>,
}

impl<T: Float + Debug + Send + Sync + 'static + scirs2_core::ndarray::ScalarOperand>
    CryptographicAggregator<T>
{
    /// Create new cryptographic aggregator
    pub fn new(config: SMPCConfig) -> Self {
        Self {
            config,
            commitment_scheme: CommitmentScheme::new(),
            verification_params: VerificationParameters::new(),
            aggregation_proofs: Vec::new(),
        }
    }

    /// Perform secure aggregation with cryptographic guarantees
    pub fn secure_aggregate(
        &mut self,
        participant_inputs: &HashMap<String, Array1<T>>,
        participants: &HashMap<String, Participant>,
    ) -> Result<SecureAggregationResult<T>> {
        // Phase 1: Input commitment
        let commitments = self.commit_inputs(participant_inputs)?;

        // Phase 2: Malicious behavior detection
        let honest_participants = self.detect_malicious_behavior(participants, &commitments)?;

        // Phase 3: Secure aggregation
        let aggregate = self.aggregate_honest_inputs(participant_inputs, &honest_participants)?;

        // Phase 4: Generate aggregation proof
        let proof = self.generate_aggregation_proof(&aggregate, &commitments)?;

        Ok(SecureAggregationResult {
            aggregate,
            honest_participants,
            proof,
            security_level: self.config.communication_security,
        })
    }

    /// Commit to input values
    fn commit_inputs(
        &mut self,
        inputs: &HashMap<String, Array1<T>>,
    ) -> Result<HashMap<String, Vec<u8>>> {
        let mut commitments = HashMap::new();

        for (participant_id, input) in inputs {
            let commitment = self.commitment_scheme.commit(input)?;
            commitments.insert(participant_id.clone(), commitment);
        }

        Ok(commitments)
    }

    /// Detect malicious behavior
    fn detect_malicious_behavior(
        &self,
        participants: &HashMap<String, Participant>,
        commitments: &HashMap<String, Vec<u8>>,
    ) -> Result<Vec<String>> {
        let mut honest_participants = Vec::new();

        for (participant_id, participant) in participants {
            if let Some(commitment) = commitments.get(participant_id) {
                // Verify commitment and check participant status
                let is_honest = self.verify_participant_honesty(participant, commitment)?;

                if is_honest {
                    honest_participants.push(participant_id.clone());
                }
            }
        }

        // Ensure we have enough honest participants
        if honest_participants.len() < self.config.threshold {
            return Err(OptimError::InvalidConfig(
                "Insufficient honest participants for secure aggregation".to_string(),
            ));
        }

        Ok(honest_participants)
    }

    /// Aggregate inputs from honest participants
    fn aggregate_honest_inputs(
        &self,
        inputs: &HashMap<String, Array1<T>>,
        honest_participants: &[String],
    ) -> Result<Array1<T>> {
        if honest_participants.is_empty() {
            return Err(OptimError::InvalidConfig(
                "No honest _participants for aggregation".to_string(),
            ));
        }

        // Get the first honest participant's input to determine dimensions
        let first_participant = &honest_participants[0];
        let first_input = inputs.get(first_participant).ok_or_else(|| {
            OptimError::InvalidConfig("Missing input for participant".to_string())
        })?;

        let mut aggregate = Array1::zeros(first_input.len());
        let mut count = 0;

        for participant_id in honest_participants {
            if let Some(input) = inputs.get(participant_id) {
                aggregate = aggregate + input;
                count += 1;
            }
        }

        if count > 0 {
            aggregate = aggregate / T::from(count).unwrap_or_else(|| T::zero());
        }

        Ok(aggregate)
    }

    /// Generate aggregation proof
    fn generate_aggregation_proof(
        &mut self,
        aggregate: &Array1<T>,
        commitments: &HashMap<String, Vec<u8>>,
    ) -> Result<AggregationProof<T>> {
        let proof = AggregationProof {
            aggregate_commitment: self.commitment_scheme.commit(aggregate)?,
            participant_commitments: commitments.clone(),
            verification_data: self
                .verification_params
                .generate_verification_data(aggregate)?,
            timestamp: std::time::SystemTime::now(),
            _phantom: std::marker::PhantomData,
        };

        self.aggregation_proofs.push(proof.clone());
        Ok(proof)
    }

    /// Verify participant honesty
    fn verify_participant_honesty(
        &self,
        participant: &Participant,
        commitment: &[u8],
    ) -> Result<bool> {
        // Check participant status
        if matches!(
            participant.status,
            ParticipantStatus::Malicious | ParticipantStatus::Suspicious
        ) {
            return Ok(false);
        }

        // Verify commitment if participant has one
        if let Some(participant_commitment) = &participant.commitment {
            if participant_commitment != commitment {
                return Ok(false);
            }
        }

        // Check trust score
        Ok(participant.trust_score >= self.config.malicious_tolerance.verification_threshold)
    }
}

/// Commitment scheme for input values
pub struct CommitmentScheme<T: Float + Debug + Send + Sync + 'static> {
    /// Random commitment key
    commitment_key: Vec<u8>,

    /// Phantom data to mark type parameter as intentionally unused
    _phantom: std::marker::PhantomData<T>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for CommitmentScheme<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> CommitmentScheme<T> {
    /// Create new commitment scheme
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let commitment_key: Vec<u8> = (0..32).map(|_| rng.gen_range(0..255)).collect();

        Self {
            commitment_key,
            _phantom: std::marker::PhantomData,
        }
    }

    /// Commit to a value
    pub fn commit(&self, value: &Array1<T>) -> Result<Vec<u8>> {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();
        hasher.update(&self.commitment_key);

        // Convert array to bytes
        for &v in value.iter() {
            let v_bytes = v.to_f64().expect("unwrap failed").to_le_bytes();
            hasher.update(v_bytes);
        }

        Ok(hasher.finalize().to_vec())
    }
}

/// Verification parameters for aggregation
pub struct VerificationParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Verification key
    verification_key: Vec<u8>,

    /// Parameters for proof generation
    proof_params: ProofParameters<T>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for VerificationParameters<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> VerificationParameters<T> {
    /// Create new verification parameters
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let verification_key: Vec<u8> = (0..64).map(|_| rng.gen_range(0..255)).collect();

        Self {
            verification_key,
            proof_params: ProofParameters::new(),
        }
    }

    /// Generate verification data for aggregation result
    pub fn generate_verification_data(&self, aggregate: &Array1<T>) -> Result<Vec<u8>> {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();
        hasher.update(&self.verification_key);

        for &v in aggregate.iter() {
            let v_bytes = v.to_f64().expect("unwrap failed").to_le_bytes();
            hasher.update(v_bytes);
        }

        Ok(hasher.finalize().to_vec())
    }
}

/// Proof parameters for cryptographic operations
pub struct ProofParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Generator elements
    generators: Vec<T>,

    /// Proof system parameters
    system_params: Vec<u8>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for ProofParameters<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> ProofParameters<T> {
    /// Create new proof parameters
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let generators: Vec<T> = (0..16)
            .map(|_| T::from(rng.gen_range(0.0..1.0)).expect("unwrap failed"))
            .collect();
        let system_params: Vec<u8> = (0..128).map(|_| rng.gen_range(0..255)).collect();

        Self {
            generators,
            system_params,
        }
    }
}

/// Homomorphic encryption engine
pub struct HomomorphicEngine<T: Float + Debug + Send + Sync + 'static> {
    /// Encryption parameters
    params: HomomorphicParameters<T>,

    /// Public key
    public_key: Vec<u8>,

    /// Private key (for demonstration - in practice would be distributed)
    private_key: Vec<u8>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for HomomorphicEngine<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> HomomorphicEngine<T> {
    /// Create new homomorphic encryption engine
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let public_key: Vec<u8> = (0..256).map(|_| rng.gen_range(0..255)).collect();
        let private_key: Vec<u8> = (0..256).map(|_| rng.gen_range(0..255)).collect();

        Self {
            params: HomomorphicParameters::new(),
            public_key,
            private_key,
        }
    }

    /// Encrypt array homomorphically
    pub fn encrypt(&self, data: &Array1<T>) -> Result<HomomorphicCiphertext<T>> {
        // Simplified homomorphic encryption (in practice would use FHE libraries)
        let mut encrypted_data = Vec::new();

        for &value in data.iter() {
            let encrypted_value = self.encrypt_value(value)?;
            encrypted_data.push(encrypted_value);
        }

        Ok(HomomorphicCiphertext {
            data: encrypted_data,
            params: self.params.clone(),
        })
    }

    /// Decrypt homomorphic ciphertext
    pub fn decrypt(&self, ciphertext: &HomomorphicCiphertext<T>) -> Result<Array1<T>> {
        let mut decrypted_data = Vec::new();

        for encrypted_value in &ciphertext.data {
            let decrypted_value = self.decrypt_value(encrypted_value)?;
            decrypted_data.push(decrypted_value);
        }

        Ok(Array1::from(decrypted_data))
    }

    /// Add encrypted values
    pub fn add_encrypted(
        &self,
        a: &HomomorphicCiphertext<T>,
        b: &HomomorphicCiphertext<T>,
    ) -> Result<HomomorphicCiphertext<T>> {
        if a.data.len() != b.data.len() {
            return Err(OptimError::InvalidConfig(
                "Ciphertext dimensions don't match".to_string(),
            ));
        }

        let mut result_data = Vec::new();

        for (a_val, b_val) in a.data.iter().zip(b.data.iter()) {
            let sum = self.add_encrypted_values(a_val, b_val)?;
            result_data.push(sum);
        }

        Ok(HomomorphicCiphertext {
            data: result_data,
            params: self.params.clone(),
        })
    }

    /// Encrypt single value
    fn encrypt_value(&self, value: T) -> Result<Vec<u8>> {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();
        hasher.update(&self.public_key);
        hasher.update(value.to_f64().expect("unwrap failed").to_le_bytes());

        Ok(hasher.finalize().to_vec())
    }

    /// Decrypt single value
    fn decrypt_value(&self, encrypted: &[u8]) -> Result<T> {
        // Simplified decryption (in practice would use proper FHE decryption)
        let mut value_bytes = [0u8; 8];
        value_bytes.copy_from_slice(&encrypted[0..8]);
        let value = f64::from_le_bytes(value_bytes);

        Ok(T::from(value).unwrap_or_else(|| T::zero()))
    }

    /// Add encrypted values
    fn add_encrypted_values(&self, a: &[u8], b: &[u8]) -> Result<Vec<u8>> {
        // Simplified homomorphic addition
        let mut result = Vec::with_capacity(a.len());

        for (a_byte, b_byte) in a.iter().zip(b.iter()) {
            result.push(a_byte.wrapping_add(*b_byte));
        }

        Ok(result)
    }
}

/// Homomorphic encryption parameters
#[derive(Debug, Clone)]
pub struct HomomorphicParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Security level
    pub security_level: usize,

    /// Noise parameters
    pub noise_params: Vec<T>,

    /// Modulus for arithmetic
    pub modulus: u128,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for HomomorphicParameters<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> HomomorphicParameters<T> {
    /// Create new homomorphic parameters
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let noise_params: Vec<T> = (0..8)
            .map(|_| T::from(rng.gen_range(0.0..1.0)).expect("unwrap failed"))
            .collect();

        Self {
            security_level: 128,
            noise_params,
            modulus: 2u128.pow(64) - 1,
        }
    }
}

/// Homomorphic ciphertext
#[derive(Debug, Clone)]
pub struct HomomorphicCiphertext<T: Float + Debug + Send + Sync + 'static> {
    /// Encrypted data
    pub data: Vec<Vec<u8>>,

    /// Encryption parameters
    pub params: HomomorphicParameters<T>,
}

/// Zero-knowledge proof system
pub struct ZKProofSystem<T: Float + Debug + Send + Sync + 'static> {
    /// Proof parameters
    params: ZKProofParameters<T>,

    /// Common reference string
    crs: Vec<u8>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for ZKProofSystem<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> ZKProofSystem<T> {
    /// Create new zero-knowledge proof system
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let crs: Vec<u8> = (0..512).map(|_| rng.gen_range(0..255)).collect();

        Self {
            params: ZKProofParameters::new(),
            crs,
        }
    }

    /// Generate proof of correct computation
    pub fn prove_computation(
        &self,
        input: &Array1<T>,
        output: &Array1<T>,
        computation: &str,
    ) -> Result<ZKProof<T>> {
        // Simplified ZK proof generation
        let proof = ZKProof {
            statement: format!("Computed {} on input", computation),
            witness: self.generate_witness(input, output)?,
            proof_data: self.generate_proof_data(input, output)?,
            verification_key: self.crs.clone(),
            _phantom: std::marker::PhantomData,
        };

        Ok(proof)
    }

    /// Verify zero-knowledge proof
    pub fn verify_proof(&self, proof: &ZKProof<T>) -> Result<bool> {
        // Simplified verification (in practice would use proper ZK verification)
        Ok(!proof.proof_data.is_empty() && proof.verification_key == self.crs)
    }

    /// Generate witness for proof
    fn generate_witness(&self, input: &Array1<T>, output: &Array1<T>) -> Result<Vec<u8>> {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();

        for &v in input.iter() {
            hasher.update(v.to_f64().expect("unwrap failed").to_le_bytes());
        }

        for &v in output.iter() {
            hasher.update(v.to_f64().expect("unwrap failed").to_le_bytes());
        }

        Ok(hasher.finalize().to_vec())
    }

    /// Generate proof data
    fn generate_proof_data(&self, input: &Array1<T>, output: &Array1<T>) -> Result<Vec<u8>> {
        use sha2::{Digest, Sha256};

        let mut hasher = Sha256::new();
        hasher.update(&self.crs);

        let witness = self.generate_witness(input, output)?;
        hasher.update(&witness);

        Ok(hasher.finalize().to_vec())
    }
}

/// Zero-knowledge proof parameters
#[derive(Debug, Clone)]
pub struct ZKProofParameters<T: Float + Debug + Send + Sync + 'static> {
    /// Security parameter
    pub security_param: usize,

    /// Proof system type
    pub proof_type: ZKProofType,

    /// Circuit parameters
    pub circuit_params: Vec<T>,
}

impl<T: Float + Debug + Send + Sync + 'static> Default for ZKProofParameters<T> {
    fn default() -> Self {
        Self::new()
    }
}

impl<T: Float + Debug + Send + Sync + 'static> ZKProofParameters<T> {
    /// Create new ZK proof parameters
    pub fn new() -> Self {
        let mut rng = scirs2_core::random::Random::seed(42);
        let circuit_params: Vec<T> = (0..16)
            .map(|_| T::from(rng.gen_range(0.0..1.0)).expect("unwrap failed"))
            .collect();

        Self {
            security_param: 128,
            proof_type: ZKProofType::SNARK,
            circuit_params,
        }
    }
}

/// Zero-knowledge proof types
#[derive(Debug, Clone, Copy)]
pub enum ZKProofType {
    /// Succinct Non-Interactive Arguments of Knowledge
    SNARK,

    /// Scalable Transparent Arguments of Knowledge
    STARK,

    /// Bulletproofs
    Bulletproof,
}

/// Zero-knowledge proof
#[derive(Debug, Clone)]
pub struct ZKProof<T: Float + Debug + Send + Sync + 'static> {
    /// Statement being proved
    pub statement: String,

    /// Witness data
    pub witness: Vec<u8>,

    /// Proof data
    pub proof_data: Vec<u8>,

    /// Verification key
    pub verification_key: Vec<u8>,

    /// Phantom data to mark type parameter as intentionally unused
    _phantom: std::marker::PhantomData<T>,
}

/// Aggregation proof
#[derive(Debug, Clone)]
pub struct AggregationProof<T: Float + Debug + Send + Sync + 'static> {
    /// Commitment to aggregate result
    pub aggregate_commitment: Vec<u8>,

    /// Participant commitments
    pub participant_commitments: HashMap<String, Vec<u8>>,

    /// Verification data
    pub verification_data: Vec<u8>,

    /// Timestamp of proof generation
    pub timestamp: std::time::SystemTime,

    /// Phantom data to mark type parameter as intentionally unused
    _phantom: std::marker::PhantomData<T>,
}

/// Secure aggregation result
#[derive(Debug, Clone)]
pub struct SecureAggregationResult<T: Float + Debug + Send + Sync + 'static> {
    /// Aggregated result
    pub aggregate: Array1<T>,

    /// List of honest participants
    pub honest_participants: Vec<String>,

    /// Cryptographic proof of correctness
    pub proof: AggregationProof<T>,

    /// Security level achieved
    pub security_level: CommunicationSecurity,
}

impl<T: Float + Debug + Send + Sync + 'static + scirs2_core::ndarray::ScalarOperand>
    SMPCCoordinator<T>
{
    /// Create new SMPC coordinator
    pub fn new(config: SMPCConfig) -> Result<Self> {
        let secret_sharing = ShamirSecretSharing::new(config.threshold, config.num_participants);
        let secure_aggregator = CryptographicAggregator::new(config.clone());
        let homomorphic_engine = HomomorphicEngine::new();
        let zk_proof_system = ZKProofSystem::new();

        Ok(Self {
            config,
            secret_sharing,
            secure_aggregator,
            homomorphic_engine,
            zk_proof_system,
            participants: HashMap::new(),
            protocol_state: SMPCProtocolState::Initialization,
        })
    }

    /// Add participant to the protocol
    pub fn add_participant(&mut self, participant: Participant) -> Result<()> {
        if self.participants.len() >= self.config.num_participants {
            return Err(OptimError::InvalidConfig(
                "Maximum number of participants reached".to_string(),
            ));
        }

        self.participants
            .insert(participant.id.clone(), participant);
        Ok(())
    }

    /// Execute secure multi-party computation
    pub fn execute_smpc(
        &mut self,
        participant_inputs: HashMap<String, Array1<T>>,
        computation: SMPCComputation,
    ) -> Result<SMPCResult<T>> {
        // Phase 1: Setup and initialization
        self.protocol_state = SMPCProtocolState::Setup;
        self.verify_participants()?;

        // Phase 2: Input sharing
        self.protocol_state = SMPCProtocolState::InputSharing;
        let shared_inputs = self.share_inputs(&participant_inputs)?;

        // Phase 3: Secure computation
        self.protocol_state = SMPCProtocolState::Computation;
        let computation_result = self.perform_secure_computation(&shared_inputs, computation)?;

        // Phase 4: Output reconstruction
        self.protocol_state = SMPCProtocolState::OutputReconstruction;
        let result = self.reconstruct_output(&computation_result)?;

        // Phase 5: Generate proofs
        let proof = self.generate_computation_proof(&participant_inputs, &result)?;

        self.protocol_state = SMPCProtocolState::Completed;

        Ok(SMPCResult {
            result,
            proof,
            participating_parties: self.participants.keys().cloned().collect(),
            security_guarantees: self.get_security_guarantees(),
        })
    }

    /// Verify participants are ready for protocol
    fn verify_participants(&self) -> Result<()> {
        if self.participants.len() < self.config.threshold {
            return Err(OptimError::InvalidConfig(
                "Insufficient participants for protocol".to_string(),
            ));
        }

        let active_participants: Vec<_> = self
            .participants
            .values()
            .filter(|p| matches!(p.status, ParticipantStatus::Active))
            .collect();

        if active_participants.len() < self.config.threshold {
            return Err(OptimError::InvalidConfig(
                "Insufficient active participants".to_string(),
            ));
        }

        Ok(())
    }

    /// Share inputs using secret sharing
    fn share_inputs(
        &mut self,
        inputs: &HashMap<String, Array1<T>>,
    ) -> Result<HashMap<String, Vec<(usize, T)>>> {
        let mut shared_inputs = HashMap::new();

        for (participant_id, input) in inputs {
            let mut participant_shares = Vec::new();

            // Share each element of the input array
            for &value in input.iter() {
                let shares = self.secret_sharing.share_secret(value)?;
                participant_shares.extend(shares);
            }

            shared_inputs.insert(participant_id.clone(), participant_shares);
        }

        Ok(shared_inputs)
    }

    /// Perform secure computation on shared inputs
    fn perform_secure_computation(
        &self,
        shared_inputs: &HashMap<String, Vec<(usize, T)>>,
        computation: SMPCComputation,
    ) -> Result<Vec<(usize, T)>> {
        match computation {
            SMPCComputation::Sum => self.secure_sum(shared_inputs),
            SMPCComputation::Average => self.secure_average(shared_inputs),
            SMPCComputation::WeightedSum(_) => self.secure_weighted_sum(shared_inputs),
            SMPCComputation::Custom(_) => self.secure_custom_computation(shared_inputs),
        }
    }

    /// Secure sum computation
    fn secure_sum(
        &self,
        shared_inputs: &HashMap<String, Vec<(usize, T)>>,
    ) -> Result<Vec<(usize, T)>> {
        // Get the first participant's shares to determine structure
        let first_shares = shared_inputs
            .values()
            .next()
            .ok_or_else(|| OptimError::InvalidConfig("No shared _inputs provided".to_string()))?;

        let mut result_shares = vec![(0usize, T::zero()); first_shares.len()];

        // Add all shares element-wise
        for shares in shared_inputs.values() {
            for (i, &(share_idx, share_val)) in shares.iter().enumerate() {
                if i < result_shares.len() {
                    result_shares[i] = (share_idx, result_shares[i].1 + share_val);
                }
            }
        }

        Ok(result_shares)
    }

    /// Secure average computation
    fn secure_average(
        &self,
        shared_inputs: &HashMap<String, Vec<(usize, T)>>,
    ) -> Result<Vec<(usize, T)>> {
        let sum_shares = self.secure_sum(shared_inputs)?;
        let num_participants = T::from(shared_inputs.len()).expect("unwrap failed");

        // Divide by number of participants
        let avg_shares: Vec<(usize, T)> = sum_shares
            .into_iter()
            .map(|(idx, val)| (idx, val / num_participants))
            .collect();

        Ok(avg_shares)
    }

    /// Secure weighted sum computation
    fn secure_weighted_sum(
        &self,
        _shared_inputs: &HashMap<String, Vec<(usize, T)>>,
    ) -> Result<Vec<(usize, T)>> {
        // Placeholder for weighted sum implementation
        Err(OptimError::InvalidConfig(
            "Weighted sum not implemented yet".to_string(),
        ))
    }

    /// Secure custom computation
    fn secure_custom_computation(
        &self,
        _shared_inputs: &HashMap<String, Vec<(usize, T)>>,
    ) -> Result<Vec<(usize, T)>> {
        // Placeholder for custom computation implementation
        Err(OptimError::InvalidConfig(
            "Custom computation not implemented yet".to_string(),
        ))
    }

    /// Reconstruct output from shares
    fn reconstruct_output(&self, shares: &[(usize, T)]) -> Result<Array1<T>> {
        // For simplicity, assume shares represent a single value
        // In practice, would need to handle multi-dimensional reconstruction
        let reconstructed_value = self.secret_sharing.reconstruct_secret(shares)?;
        Ok(Array1::from(vec![reconstructed_value]))
    }

    /// Generate proof of correct computation
    fn generate_computation_proof(
        &self,
        inputs: &HashMap<String, Array1<T>>,
        result: &Array1<T>,
    ) -> Result<ZKProof<T>> {
        // Combine all inputs for proof generation
        let combined_input = self.combine_inputs(inputs)?;

        self.zk_proof_system
            .prove_computation(&combined_input, result, "SMPC aggregation")
    }

    /// Combine inputs for proof generation
    fn combine_inputs(&self, inputs: &HashMap<String, Array1<T>>) -> Result<Array1<T>> {
        let mut combined = Vec::new();

        for input in inputs.values() {
            combined.extend(input.iter().copied());
        }

        Ok(Array1::from(combined))
    }

    /// Get security guarantees
    fn get_security_guarantees(&self) -> SMPCSecurityGuarantees {
        SMPCSecurityGuarantees {
            protocol_variant: self.config.protocol_variant,
            communication_security: self.config.communication_security,
            malicious_tolerance: self.config.malicious_tolerance.max_corrupted,
            privacy_level: PrivacyLevel::InformationTheoretic,
            completeness: true,
            soundness: true,
        }
    }
}

/// SMPC computation types
#[derive(Debug, Clone)]
pub enum SMPCComputation {
    /// Sum of all inputs
    Sum,

    /// Average of all inputs
    Average,

    /// Weighted sum with given weights
    WeightedSum(Vec<f64>),

    /// Custom computation function
    Custom(String),
}

/// SMPC computation result
#[derive(Debug, Clone)]
pub struct SMPCResult<T: Float + Debug + Send + Sync + 'static> {
    /// Computation result
    pub result: Array1<T>,

    /// Zero-knowledge proof of correctness
    pub proof: ZKProof<T>,

    /// Participating parties
    pub participating_parties: Vec<String>,

    /// Security guarantees achieved
    pub security_guarantees: SMPCSecurityGuarantees,
}

/// SMPC security guarantees
#[derive(Debug, Clone)]
pub struct SMPCSecurityGuarantees {
    /// Protocol variant used
    pub protocol_variant: SMPCProtocol,

    /// Communication security level
    pub communication_security: CommunicationSecurity,

    /// Number of malicious parties tolerated
    pub malicious_tolerance: usize,

    /// Privacy level achieved
    pub privacy_level: PrivacyLevel,

    /// Completeness guarantee
    pub completeness: bool,

    /// Soundness guarantee
    pub soundness: bool,
}

/// Privacy levels for SMPC
#[derive(Debug, Clone, Copy)]
pub enum PrivacyLevel {
    /// Computational privacy
    Computational,

    /// Information-theoretic privacy
    InformationTheoretic,

    /// Perfect privacy
    Perfect,
}

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

    #[test]
    fn test_secret_sharing() {
        let mut secret_sharing = ShamirSecretSharing::<f64>::new(3, 5);
        let secret = 42.0;

        let shares = secret_sharing.share_secret(secret).expect("unwrap failed");
        assert_eq!(shares.len(), 5);

        let reconstructed = secret_sharing
            .reconstruct_secret(&shares[0..3])
            .expect("unwrap failed");
        assert!((reconstructed - secret).abs() < 1e-10);
    }

    #[test]
    fn test_smpc_config() {
        let config = SMPCConfig {
            num_participants: 5,
            threshold: 3,
            security_parameter: 128,
            enable_homomorphic: true,
            enable_zk_proofs: true,
            protocol_variant: SMPCProtocol::BGW,
            communication_security: CommunicationSecurity::SemiHonest,
            malicious_tolerance: MaliciousTolerance {
                max_corrupted: 1,
                byzantine_tolerance: true,
                verification_threshold: 0.8,
                commit_and_prove: true,
            },
        };

        assert_eq!(config.num_participants, 5);
        assert_eq!(config.threshold, 3);
        assert!(config.enable_homomorphic);
    }

    #[test]
    fn test_commitment_scheme() {
        let commitment_scheme = CommitmentScheme::<f64>::new();
        let data = Array1::from(vec![1.0, 2.0, 3.0]);

        let commitment1 = commitment_scheme.commit(&data).expect("unwrap failed");
        let commitment2 = commitment_scheme.commit(&data).expect("unwrap failed");

        // Same data should produce same commitment
        assert_eq!(commitment1, commitment2);

        let different_data = Array1::from(vec![1.0, 2.0, 4.0]);
        let commitment3 = commitment_scheme
            .commit(&different_data)
            .expect("unwrap failed");

        // Different data should produce different commitment
        assert_ne!(commitment1, commitment3);
    }

    #[test]
    fn test_homomorphic_encryption() {
        let he = HomomorphicEngine::<f64>::new();
        let data1 = Array1::from(vec![1.0, 2.0, 3.0]);
        let data2 = Array1::from(vec![4.0, 5.0, 6.0]);

        let encrypted1 = he.encrypt(&data1).expect("unwrap failed");
        let encrypted2 = he.encrypt(&data2).expect("unwrap failed");

        let encrypted_sum = he
            .add_encrypted(&encrypted1, &encrypted2)
            .expect("unwrap failed");
        let decrypted_sum = he.decrypt(&encrypted_sum).expect("unwrap failed");

        // Note: This is a simplified test - real homomorphic encryption would preserve the sum
        assert_eq!(decrypted_sum.len(), 3);
    }
}