use thiserror::Error;

use std::time::{Duration, SystemTime, UNIX_EPOCH};

/// Errors returned when the system clock cannot be represented as MTP time.
#[derive(Clone, Copy, Debug, Error, PartialEq, Eq)]
pub enum TimeError {
    #[error("system clock is before the Unix epoch")]
    BeforeUnixEpoch,
    #[error("Unix epoch milliseconds exceed the u64 range")]
    OutOfRange,
}

fn duration_to_unix_time_millis(duration: Duration) -> Result<u64, TimeError> {
    u64::try_from(duration.as_millis()).map_err(|_| TimeError::OutOfRange)
}

/// Return the current Unix time in milliseconds.
///
/// MTP protocol fields that use `CreatedAt` store this value as an unsigned
/// integer. The conversion is centralized here so native writers do not
/// accidentally use seconds.
pub fn unix_time_millis() -> Result<u64, TimeError> {
    let duration = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map_err(|_| TimeError::BeforeUnixEpoch)?;
    duration_to_unix_time_millis(duration)
}

#[derive(Clone, Debug, Error, PartialEq, Eq)]
pub enum CodecError {
    #[error("Unknown version")]
    UnknownVersion,
    #[error("Unknown communication type: {0}")]
    UnknownCommunicationType(String),
    #[error("Unknown data type: {0}")]
    UnknownDataType(String),
    #[error("Reserved communication type: {0}")]
    ReservedCommunicationType(u16),
    #[error("Invalid encoding")]
    InvalidEncoding,
    #[error("Too many entries to encode")]
    TooManyEntries,
    #[error("Crypto failed: {0}")]
    CryptoFailed(String),
    #[error("Missing required field: {0}")]
    MissingField(String),
}

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

    #[test]
    fn unix_time_millis_preserves_subsecond_precision() {
        let duration = Duration::new(1_786_449_600, 123_000_000);
        assert_eq!(
            duration_to_unix_time_millis(duration),
            Ok(1_786_449_600_123)
        );
    }

    #[test]
    fn unix_time_millis_rejects_values_outside_u64() {
        let duration = Duration::new(u64::MAX, 0);
        assert_eq!(
            duration_to_unix_time_millis(duration),
            Err(TimeError::OutOfRange)
        );
    }

    #[test]
    fn test_codec_error_display() {
        let e = CodecError::InvalidEncoding;
        assert_eq!(format!("{}", e), "Invalid encoding");
    }

    #[test]
    fn test_codec_error_unknown_version() {
        assert_eq!(format!("{}", CodecError::UnknownVersion), "Unknown version");
    }

    #[test]
    fn test_codec_error_clone_eq() {
        let a = CodecError::InvalidEncoding;
        let b = a.clone();
        assert_eq!(a, b);
    }
}

/* CommunicationError
 *
 * On native targets the full variant set (including quinn / wtransport
 * wrappers) is available.  On WASM only the transport-independent subset is
 * compiled. */

#[derive(Debug, Error, Clone)]
pub enum CommunicationError {
    #[error("Use after Closed")]
    UseAfterClosed,

    #[error("Connection closed by local shutdown")]
    ClosedLocally,

    #[error("Connection closed by peer")]
    ClosedByPeer,

    #[error("Connection terminated unexpectedly")]
    ConnectionLost,

    #[error("QUIC error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    Quinn(#[from] quinn::ConnectionError),

    #[error("ParseCommunicationValue error")]
    ParseCommunicationValue,

    #[error("Encode error")]
    Encode,

    #[error("Parse Certificate error")]
    CertificateParseFailed,

    #[error("Loading Certificate error")]
    CertificateLoadFailed,

    #[error("Parse error: {0}")]
    ParseError(String),

    #[error("Connection error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    ConnectionError(#[from] wtransport::error::ConnectionError),

    #[error("Connecting error: {0}")]
    ConnectingError(String),

    #[error("ReadToEnd error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    ReadToEndError(#[from] quinn::ReadToEndError),

    #[error("Write error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    WriteError(#[from] quinn::WriteError),

    #[error("Closed error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    ClosedError(#[from] quinn::ClosedStream),

    #[error("Message too large")]
    MessageTooLarge,

    #[error("ReadExactError: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    ReadExactError(#[from] quinn::ReadExactError),

    #[error("Stream Closed")]
    StreamClosed,

    #[error("Stream Error")]
    StreamError,

    #[error("Stream Error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    StreamWriteError(#[from] wtransport::error::StreamWriteError),

    #[error("Read Exact Error: {0}")]
    #[cfg(not(target_arch = "wasm32"))]
    StreamReadExactError(#[from] wtransport::error::StreamReadExactError),

    #[error("Crypto Provider Install Error")]
    CryptoProviderInstallFailed,

    #[error("Authentication failed: {0}")]
    AuthenticationFailed(String),

    #[error("Other: {0}")]
    Other(String),
}

// ---- manual PartialEq (quinn / wtransport types don't impl PartialEq) ----

impl PartialEq for CommunicationError {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::UseAfterClosed, Self::UseAfterClosed) => true,
            (Self::ClosedLocally, Self::ClosedLocally) => true,
            (Self::ClosedByPeer, Self::ClosedByPeer) => true,
            (Self::ConnectionLost, Self::ConnectionLost) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::Quinn(_), Self::Quinn(_)) => true,
            (Self::ParseCommunicationValue, Self::ParseCommunicationValue) => true,
            (Self::Encode, Self::Encode) => true,
            (Self::CertificateParseFailed, Self::CertificateParseFailed) => true,
            (Self::CertificateLoadFailed, Self::CertificateLoadFailed) => true,
            (Self::ParseError(a), Self::ParseError(b)) => a == b,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::ConnectionError(_), Self::ConnectionError(_)) => true,
            (Self::ConnectingError(a), Self::ConnectingError(b)) => a == b,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::ReadToEndError(_), Self::ReadToEndError(_)) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::WriteError(_), Self::WriteError(_)) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::ClosedError(_), Self::ClosedError(_)) => true,
            (Self::MessageTooLarge, Self::MessageTooLarge) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::ReadExactError(_), Self::ReadExactError(_)) => true,
            (Self::StreamClosed, Self::StreamClosed) => true,
            (Self::StreamError, Self::StreamError) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::StreamWriteError(_), Self::StreamWriteError(_)) => true,
            #[cfg(not(target_arch = "wasm32"))]
            (Self::StreamReadExactError(_), Self::StreamReadExactError(_)) => true,
            (Self::CryptoProviderInstallFailed, Self::CryptoProviderInstallFailed) => true,
            (Self::AuthenticationFailed(a), Self::AuthenticationFailed(b)) => a == b,
            (Self::Other(a), Self::Other(b)) => a == b,
            _ => false,
        }
    }
}

impl Eq for CommunicationError {}

/* ================================ PipeError ================================ */

#[cfg(feature = "pipes")]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum PipeError {
    Rejected,
    HandshakeTimeout,
    StreamClosed,
    IoError(String),
    ConnectionClosed,
}

#[cfg(feature = "pipes")]
impl std::fmt::Display for PipeError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PipeError::Rejected => write!(f, "pipe request was rejected"),
            PipeError::HandshakeTimeout => write!(f, "pipe handshake timed out"),
            PipeError::StreamClosed => write!(f, "pipe stream closed unexpectedly"),
            PipeError::IoError(s) => write!(f, "pipe I/O error: {s}"),
            PipeError::ConnectionClosed => write!(f, "connection closed"),
        }
    }
}

#[cfg(feature = "pipes")]
impl std::error::Error for PipeError {}

#[cfg(feature = "pipes")]
impl From<CommunicationError> for PipeError {
    fn from(e: CommunicationError) -> Self {
        match e {
            CommunicationError::StreamClosed => PipeError::StreamClosed,
            CommunicationError::ConnectionError(_) => PipeError::ConnectionClosed,
            other => PipeError::IoError(other.to_string()),
        }
    }
}

/* ===================== Handshake Outcome Types ===================== */

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RejectionReason {
    BadVersion { supported_versions: Vec<String> },
    AuthenticationFailed { detail: String },
    RateLimited,
}

impl std::fmt::Display for RejectionReason {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            RejectionReason::BadVersion { supported_versions } => {
                write!(
                    f,
                    "unsupported protocol version; supported: {}",
                    supported_versions.join(", ")
                )
            }
            RejectionReason::AuthenticationFailed { detail } => {
                write!(f, "authentication failed: {detail}")
            }
            RejectionReason::RateLimited => write!(f, "rate limited"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum HandshakeOutcome {
    Accepted { version: String, assigned_id: u64 },
    Rejected { reason: RejectionReason },
}

impl std::fmt::Display for HandshakeOutcome {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            HandshakeOutcome::Accepted {
                version,
                assigned_id,
            } => {
                write!(f, "accepted (version={version}, id={assigned_id})")
            }
            HandshakeOutcome::Rejected { reason } => write!(f, "rejected: {reason}"),
        }
    }
}

/* ================================ TESTS ================================ */
#[cfg(test)]
mod communication_error_tests {
    use super::*;

    #[test]
    fn test_communication_error_display() {
        assert_eq!(
            format!("{}", CommunicationError::UseAfterClosed),
            "Use after Closed"
        );
        assert_eq!(
            format!("{}", CommunicationError::StreamClosed),
            "Stream Closed"
        );
        assert_eq!(
            format!("{}", CommunicationError::StreamError),
            "Stream Error"
        );
    }

    #[test]
    fn test_communication_error_clone() {
        let a = CommunicationError::UseAfterClosed;
        let b = a.clone();
        assert_eq!(format!("{:?}", a), format!("{:?}", b));
    }

    #[test]
    fn test_communication_error_authentication_failed() {
        let e = CommunicationError::AuthenticationFailed("bad key".into());
        assert!(format!("{}", e).contains("bad key"));
    }

    #[test]
    fn test_communication_error_other() {
        let e = CommunicationError::Other("custom error".into());
        assert!(format!("{}", e).contains("custom error"));
    }

    #[cfg(not(target_arch = "wasm32"))]
    #[test]
    fn test_connecting_error_display() {
        let e = CommunicationError::ConnectingError("refused".into());
        assert!(format!("{}", e).contains("refused"));
    }
}

/* ================================ PipeError TESTS ================================ */
#[cfg(feature = "pipes")]
#[cfg(test)]
mod pipe_error_tests {
    use super::*;

    #[test]
    fn test_pipe_error_display() {
        assert_eq!(
            format!("{}", PipeError::Rejected),
            "pipe request was rejected"
        );
        assert_eq!(
            format!("{}", PipeError::HandshakeTimeout),
            "pipe handshake timed out"
        );
        assert_eq!(
            format!("{}", PipeError::StreamClosed),
            "pipe stream closed unexpectedly"
        );
        assert_eq!(
            format!("{}", PipeError::ConnectionClosed),
            "connection closed"
        );
        assert_eq!(
            format!("{}", PipeError::IoError("boom".into())),
            "pipe I/O error: boom"
        );
    }

    #[test]
    fn test_pipe_error_from_stream_closed() {
        let pe: PipeError = CommunicationError::StreamClosed.into();
        assert_eq!(pe, PipeError::StreamClosed);
    }

    #[test]
    fn test_pipe_error_from_connection_error() {
        let pe: PipeError =
            CommunicationError::ConnectionError(wtransport::error::ConnectionError::TimedOut)
                .into();
        assert_eq!(pe, PipeError::ConnectionClosed);
    }

    #[test]
    fn test_pipe_error_from_other() {
        let pe: PipeError = CommunicationError::StreamError.into();
        assert_eq!(pe, PipeError::IoError("Stream Error".into()));
    }
}

/* ==================== HandshakeOutcome TESTS ==================== */
#[cfg(test)]
mod handshake_outcome_tests {
    use super::*;

    #[test]
    fn test_accepted_display() {
        let outcome = HandshakeOutcome::Accepted {
            version: "1.0".into(),
            assigned_id: 42,
        };
        assert_eq!(format!("{outcome}"), "accepted (version=1.0, id=42)");
    }

    #[test]
    fn test_rejected_bad_version_display() {
        let outcome = HandshakeOutcome::Rejected {
            reason: RejectionReason::BadVersion {
                supported_versions: vec!["1.0".into(), "2.0".into()],
            },
        };
        let msg = format!("{outcome}");
        assert!(msg.contains("1.0"));
        assert!(msg.contains("2.0"));
    }

    #[test]
    fn test_rejected_auth_failed_display() {
        let outcome = HandshakeOutcome::Rejected {
            reason: RejectionReason::AuthenticationFailed {
                detail: "invalid signature".into(),
            },
        };
        assert!(format!("{outcome}").contains("invalid signature"));
    }

    #[test]
    fn test_rejected_rate_limited_display() {
        let outcome = HandshakeOutcome::Rejected {
            reason: RejectionReason::RateLimited,
        };
        assert_eq!(format!("{outcome}"), "rejected: rate limited");
    }

    #[test]
    fn test_rejection_reason_display() {
        assert!(
            format!(
                "{}",
                RejectionReason::BadVersion {
                    supported_versions: vec!["1.0".into()]
                }
            )
            .contains("1.0")
        );
        assert!(
            format!(
                "{}",
                RejectionReason::AuthenticationFailed {
                    detail: "bad".into()
                }
            )
            .contains("bad")
        );
        assert_eq!(format!("{}", RejectionReason::RateLimited), "rate limited");
    }

    #[test]
    fn test_handshake_outcome_clone_eq() {
        let a = HandshakeOutcome::Accepted {
            version: "1.0".into(),
            assigned_id: 1,
        };
        let b = a.clone();
        assert_eq!(a, b);
    }
}