anya-core 1.2.0

use chrono::{DateTime, Utc};
/// Legal wrapper integration for DAO-4 [AIS-3][BPC-3][DAO-3]
// [AIR-3][AIS-3][BPC-3][RES-3] Removed unused import: std::error::Error
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use thiserror::Error;

#[derive(Debug, Error)]
pub enum LegalError {
    #[error("Invalid legal wrapper: {0}")]
    InvalidWrapper(String),

    #[error("Jurisdiction not supported: {0}")]
    UnsupportedJurisdiction(String),

    #[error("Signature verification failed: {0}")]
    SignatureError(String),
}

/// Legal entity structure for institutional DAO-4 governance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegalEntity {
    /// Entity identifier
    pub id: String,

    /// Legal name
    pub name: String,

    /// Jurisdiction of registration
    pub jurisdiction: String,

    /// Registration number
    pub registration_number: String,

    /// Registration date
    pub registration_date: DateTime<Utc>,

    /// Authorized signatories
    pub signatories: Vec<String>,

    /// Bitcoin addresses for verification (BPC-3)
    pub bitcoin_addresses: Vec<String>,
}

/// Digital signature with jurisdiction validation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LegalSignature {
    /// Who created this signature
    pub signer: String,

    /// Which legal entity they represent
    pub entity_id: String,

    /// Digital signature data
    pub signature: String,

    /// When signature was created
    pub timestamp: DateTime<Utc>,

    /// Bitcoin transaction anchoring this signature (BPC-3)
    pub bitcoin_anchor: Option<String>,

    /// Jurisdiction where this signature is valid
    pub jurisdiction: String,
}

/// Legal wrapper for cross-border DAO operation (DAO-4)
pub struct LegalWrapper {
    /// Known legal entities
    entities: HashMap<String, LegalEntity>,

    /// Supported jurisdictions
    jurisdictions: Vec<String>,

    /// Signature requirements by jurisdiction
    signature_requirements: HashMap<String, SignatureRequirement>,
}

/// Signature requirements for a jurisdiction
#[derive(Debug, Clone)]
#[allow(dead_code)]
struct SignatureRequirement {
    /// Minimum required signatures
    min_signatures: usize,

    /// Whether Bitcoin anchoring is required
    requires_bitcoin_anchor: bool,
}

impl Default for LegalWrapper {
    fn default() -> Self {
        Self::new()
    }
}

impl LegalWrapper {
    /// Create a new legal wrapper
    pub fn new() -> Self {
        let mut wrapper = Self {
            entities: HashMap::new(),
            jurisdictions: vec![
                "US".to_string(),
                "EU".to_string(),
                "UK".to_string(),
                "SG".to_string(),
            ],
            signature_requirements: HashMap::new(),
        };

        // Set up default signature requirements
        wrapper.signature_requirements.insert(
            "US".to_string(),
            SignatureRequirement {
                min_signatures: 2,
                requires_bitcoin_anchor: true,
            },
        );

        wrapper.signature_requirements.insert(
            "EU".to_string(),
            SignatureRequirement {
                min_signatures: 1,
                requires_bitcoin_anchor: true,
            },
        );

        wrapper.signature_requirements.insert(
            "UK".to_string(),
            SignatureRequirement {
                min_signatures: 1,
                requires_bitcoin_anchor: true,
            },
        );

        wrapper.signature_requirements.insert(
            "SG".to_string(),
            SignatureRequirement {
                min_signatures: 1,
                requires_bitcoin_anchor: true,
            },
        );

        wrapper
    }

    /// Register a legal entity
    pub fn register_entity(&mut self, entity: LegalEntity) -> Result<(), LegalError> {
        // Validate jurisdiction
        if !self.jurisdictions.contains(&entity.jurisdiction) {
            return Err(LegalError::UnsupportedJurisdiction(format!(
                "Jurisdiction not supported: {}",
                entity.jurisdiction
            )));
        }

        // Validate Bitcoin addresses for BPC-3 compliance
        if entity.bitcoin_addresses.is_empty() {
            return Err(LegalError::InvalidWrapper(
                "Bitcoin addresses required for BPC-3 compliance".to_string(),
            ));
        }

        // Store the entity
        self.entities.insert(entity.id.clone(), entity);

        Ok(())
    }

    /// Verify a legal signature
    pub fn verify_signature(&self, signature: &LegalSignature) -> Result<bool, LegalError> {
        // Check jurisdiction support
        if !self.jurisdictions.contains(&signature.jurisdiction) {
            return Err(LegalError::UnsupportedJurisdiction(format!(
                "Jurisdiction not supported: {}",
                signature.jurisdiction
            )));
        }

        // Get entity
        let entity = self.entities.get(&signature.entity_id).ok_or_else(|| {
            LegalError::InvalidWrapper(format!("Entity not found: {}", signature.entity_id))
        })?;

        // Check signer is authorized
        if !entity.signatories.contains(&signature.signer) {
            return Err(LegalError::SignatureError(format!(
                "Signer {} not authorized for entity {}",
                signature.signer, entity.name
            )));
        }

        // Check Bitcoin anchoring for BPC-3 compliance
        let requirements = self
            .signature_requirements
            .get(&signature.jurisdiction)
            .ok_or_else(|| {
                LegalError::UnsupportedJurisdiction(format!(
                    "No requirements for jurisdiction: {}",
                    signature.jurisdiction
                ))
            })?;

        if requirements.requires_bitcoin_anchor && signature.bitcoin_anchor.is_none() {
            return Err(LegalError::SignatureError(
                "Bitcoin anchoring required for BPC-3 compliance".to_string(),
            ));
        }

        // In a real implementation, this would verify the cryptographic signature
        // For this example, we'll just simulate successful verification

        Ok(true)
    }
}