crdhcpc 0.1.1

//! DHCPv6 client implementation
//!
//! Implements RFC 8415 (DHCPv6)

use super::*;

use std::net::{SocketAddrV6, UdpSocket};
use tokio::time::sleep;

// Conditional debug logging macro
#[cfg(feature = "dhcp-debug")]
macro_rules! dhcpv6_debug {
    ($($arg:tt)*) => {
        debug!("[{}:{}] {}", file!(), line!(), format!($($arg)*))
    };
}

#[cfg(not(feature = "dhcp-debug"))]
macro_rules! dhcpv6_debug {
    ($($arg:tt)*) => {};
}

#[cfg(feature = "dhcp-debug")]
macro_rules! dhcpv6_info {
    ($($arg:tt)*) => {
        info!("[{}:{}] {}", file!(), line!(), format!($($arg)*))
    };
}

#[cfg(not(feature = "dhcp-debug"))]
macro_rules! dhcpv6_info {
    ($($arg:tt)*) => {};
}

// DHCPv6 Constants
const DHCPV6_CLIENT_PORT: u16 = 546;
const DHCPV6_SERVER_PORT: u16 = 547;

// All_DHCP_Relay_Agents_and_Servers multicast address
const ALL_DHCP_RELAY_AGENTS_AND_SERVERS: Ipv6Addr = Ipv6Addr::new(0xff02, 0, 0, 0, 0, 0, 1, 2);

// DHCPv6 Message Types (RFC 8415)
const DHCPV6_SOLICIT: u8 = 1;
const DHCPV6_ADVERTISE: u8 = 2;
const DHCPV6_REQUEST: u8 = 3;
const DHCPV6_CONFIRM: u8 = 4;
const DHCPV6_RENEW: u8 = 5;
const DHCPV6_REBIND: u8 = 6;
const DHCPV6_REPLY: u8 = 7;
const DHCPV6_RELEASE: u8 = 8;
const DHCPV6_DECLINE: u8 = 9;
const DHCPV6_INFORMATION_REQUEST: u8 = 11;

// DHCPv6 Option Codes (RFC 8415)
const OPTION_CLIENTID: u16 = 1;
const OPTION_SERVERID: u16 = 2;
const OPTION_IA_NA: u16 = 3;
const OPTION_IA_TA: u16 = 4;
const OPTION_IAADDR: u16 = 5;
const OPTION_ORO: u16 = 6;       // Option Request Option
const OPTION_PREFERENCE: u16 = 7;
const OPTION_ELAPSED_TIME: u16 = 8;
const OPTION_STATUS_CODE: u16 = 13;
const OPTION_RAPID_COMMIT: u16 = 14;
const OPTION_DNS_SERVERS: u16 = 23;
const OPTION_DOMAIN_LIST: u16 = 24;
const OPTION_IA_PD: u16 = 25;
const OPTION_IAPREFIX: u16 = 26;

// Status Codes
const STATUS_SUCCESS: u16 = 0;
const STATUS_UNSPEC_FAIL: u16 = 1;
const STATUS_NO_ADDRS_AVAIL: u16 = 2;
const STATUS_NO_BINDING: u16 = 3;
const STATUS_NOT_ON_LINK: u16 = 4;
const STATUS_USE_MULTICAST: u16 = 5;
const STATUS_NO_PREFIX_AVAIL: u16 = 6;

// Authentication Option (RFC 8415 Section 20)
const OPTION_AUTH: u16 = 11;

// Additional DHCPv6 Message Types (RFC 7653 - Active Leasequery)
const DHCPV6_STARTTLS: u8 = 23;

// Authentication Protocols (RFC 8415 Section 20.4)
const AUTH_PROTOCOL_DELAYED: u8 = 2;        // Delayed Authentication (RFC 3315)
const AUTH_PROTOCOL_RECONFIGURE_KEY: u8 = 3; // Reconfigure Key Authentication

// Authentication Algorithms (for Delayed Authentication)
const AUTH_ALGORITHM_HMAC_MD5: u8 = 1;    // HMAC-MD5 (deprecated)
const AUTH_ALGORITHM_HMAC_SHA1: u8 = 2;   // HMAC-SHA1
const AUTH_ALGORITHM_HMAC_SHA256: u8 = 3; // HMAC-SHA256 (recommended)
const AUTH_ALGORITHM_HMAC_SHA384: u8 = 4; // HMAC-SHA384
const AUTH_ALGORITHM_HMAC_SHA512: u8 = 5; // HMAC-SHA512

// Replay Detection Method (RDM)
const RDM_MONOTONIC_COUNTER: u8 = 0; // Monotonically increasing counter

/// DHCPv6 client state
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Dhcpv6State {
    Init,
    Solicit,
    Request,
    Confirm,
    Renew,
    Rebind,
    Bound,
}

impl std::fmt::Display for Dhcpv6State {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Init => write!(f, "INIT"),
            Self::Solicit => write!(f, "SOLICIT"),
            Self::Request => write!(f, "REQUEST"),
            Self::Confirm => write!(f, "CONFIRM"),
            Self::Renew => write!(f, "RENEW"),
            Self::Rebind => write!(f, "REBIND"),
            Self::Bound => write!(f, "BOUND"),
        }
    }
}

/// DHCPv6 Identity Association for Non-temporary Addresses (IA_NA)
#[derive(Debug, Clone)]
pub struct Dhcpv6IaNa {
    pub iaid: u32,
    pub addresses: Vec<Ipv6Addr>,
    pub t1: Duration, // Renewal time
    pub t2: Duration, // Rebinding time
    pub preferred_lifetime: Duration,
    pub valid_lifetime: Duration,
    pub acquired_at: SystemTime,
}

impl Dhcpv6IaNa {
    pub fn to_info(&self) -> Dhcpv6IaNaInfo {
        Dhcpv6IaNaInfo {
            addresses: self.addresses.clone(),
            preferred_lifetime: self.preferred_lifetime,
            valid_lifetime: self.valid_lifetime,
            acquired_at: self.acquired_at,
        }
    }

    pub fn renewal_at(&self) -> SystemTime {
        self.acquired_at + self.t1
    }

    pub fn rebinding_at(&self) -> SystemTime {
        self.acquired_at + self.t2
    }

    pub fn expires_at(&self) -> SystemTime {
        self.acquired_at + self.valid_lifetime
    }

    pub fn is_expired(&self) -> bool {
        SystemTime::now() > self.expires_at()
    }
}

/// DHCPv6 Identity Association for Prefix Delegation (IA_PD)
#[derive(Debug, Clone)]
pub struct Dhcpv6IaPd {
    pub iaid: u32,
    pub prefix: Ipv6Addr,
    pub prefix_len: u8,
    pub t1: Duration,
    pub t2: Duration,
    pub preferred_lifetime: Duration,
    pub valid_lifetime: Duration,
    pub acquired_at: SystemTime,
}

impl Dhcpv6IaPd {
    pub fn to_info(&self) -> Dhcpv6IaPdInfo {
        Dhcpv6IaPdInfo {
            prefix: self.prefix,
            prefix_len: self.prefix_len,
            preferred_lifetime: self.preferred_lifetime,
            valid_lifetime: self.valid_lifetime,
            acquired_at: self.acquired_at,
        }
    }
}

/// Server information from ADVERTISE
#[derive(Debug, Clone)]
struct Dhcpv6ServerInfo {
    server_id: Vec<u8>,
    address: Ipv6Addr,
    preference: u8,
    ia_na: Option<Dhcpv6IaNa>,
    ia_pd: Option<Dhcpv6IaPd>,
    dns_servers: Vec<Ipv6Addr>,
    domain_list: Vec<String>,
}

/// DHCPv6 Authentication Context (RFC 8415 Section 20)
#[derive(Debug, Clone)]
pub struct Dhcpv6AuthContext {
    /// Authentication protocol in use
    protocol: u8,
    /// Authentication algorithm
    algorithm: u8,
    /// Pre-shared key (decoded)
    key: Option<Vec<u8>>,
    /// Key ID
    key_id: Option<u32>,
    /// Realm for delayed authentication
    realm: Option<String>,
    /// Replay detection counter
    replay_counter: u64,
    /// Server's last replay counter (for verification)
    server_replay_counter: Option<u64>,
    /// Whether authentication is enabled
    enabled: bool,
    /// Require authentication on server messages
    require_server_auth: bool,
    /// Accept unauthenticated messages (fallback)
    accept_unauthenticated: bool,
}

impl Dhcpv6AuthContext {
    /// Create authentication context from config
    pub fn from_config(config: &Dhcpv6AuthConfig) -> Self {
        let protocol = match config.protocol.as_str() {
            "reconfigure-key" => AUTH_PROTOCOL_RECONFIGURE_KEY,
            _ => AUTH_PROTOCOL_DELAYED,
        };

        let algorithm = match config.algorithm.as_str() {
            "hmac-md5" => AUTH_ALGORITHM_HMAC_MD5,
            "hmac-sha1" => AUTH_ALGORITHM_HMAC_SHA1,
            "hmac-sha384" => AUTH_ALGORITHM_HMAC_SHA384,
            "hmac-sha512" => AUTH_ALGORITHM_HMAC_SHA512,
            _ => AUTH_ALGORITHM_HMAC_SHA256,
        };

        // Decode key from hex or base64
        let key = config.key.as_ref().and_then(|k| {
            // Try hex first
            if let Ok(decoded) = hex::decode(k) {
                return Some(decoded);
            }
            // Try base64
            use base64::Engine;
            if let Ok(decoded) = base64::engine::general_purpose::STANDARD.decode(k) {
                return Some(decoded);
            }
            // Try as raw bytes
            if !k.is_empty() {
                return Some(k.as_bytes().to_vec());
            }
            None
        });

        // Generate initial replay counter from current time
        let replay_counter = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .map(|d| d.as_secs())
            .unwrap_or(0);

        Self {
            protocol,
            algorithm,
            key,
            key_id: config.key_id,
            realm: config.realm.clone(),
            replay_counter,
            server_replay_counter: None,
            enabled: config.enabled,
            require_server_auth: config.require_server_auth,
            accept_unauthenticated: config.accept_unauthenticated,
        }
    }

    /// Increment and return the replay counter
    fn next_replay_counter(&mut self) -> u64 {
        self.replay_counter += 1;
        self.replay_counter
    }

    /// Get the HMAC output length for the current algorithm
    fn hmac_length(&self) -> usize {
        match self.algorithm {
            AUTH_ALGORITHM_HMAC_MD5 => 16,     // MD5 = 128 bits
            AUTH_ALGORITHM_HMAC_SHA1 => 20,    // SHA1 = 160 bits
            AUTH_ALGORITHM_HMAC_SHA256 => 32,  // SHA256 = 256 bits
            AUTH_ALGORITHM_HMAC_SHA384 => 48,  // SHA384 = 384 bits
            AUTH_ALGORITHM_HMAC_SHA512 => 64,  // SHA512 = 512 bits
            _ => 32,
        }
    }

    /// Compute HMAC over the message
    /// For Delayed Authentication, the HMAC is computed over:
    /// - The entire DHCPv6 message with the Authentication Information field set to zeros
    fn compute_hmac(&self, message: &[u8]) -> Option<Vec<u8>> {
        use ring::hmac;

        let key = self.key.as_ref()?;

        let algorithm = match self.algorithm {
            AUTH_ALGORITHM_HMAC_SHA256 => hmac::HMAC_SHA256,
            AUTH_ALGORITHM_HMAC_SHA384 => hmac::HMAC_SHA384,
            AUTH_ALGORITHM_HMAC_SHA512 => hmac::HMAC_SHA512,
            AUTH_ALGORITHM_HMAC_SHA1 => {
                // ring doesn't have SHA1, use SHA256 as fallback with warning
                warn!("HMAC-SHA1 not directly supported by ring, using SHA256");
                hmac::HMAC_SHA256
            }
            AUTH_ALGORITHM_HMAC_MD5 => {
                // MD5 is deprecated and not supported by ring
                warn!("HMAC-MD5 is deprecated and not supported, using SHA256");
                hmac::HMAC_SHA256
            }
            _ => hmac::HMAC_SHA256,
        };

        let signing_key = hmac::Key::new(algorithm, key);
        let tag = hmac::sign(&signing_key, message);
        Some(tag.as_ref().to_vec())
    }

    /// Verify HMAC of received message
    fn verify_hmac(&self, message: &[u8], received_hmac: &[u8]) -> bool {
        use ring::hmac;

        let key = match self.key.as_ref() {
            Some(k) => k,
            None => return false,
        };

        let algorithm = match self.algorithm {
            AUTH_ALGORITHM_HMAC_SHA256 => hmac::HMAC_SHA256,
            AUTH_ALGORITHM_HMAC_SHA384 => hmac::HMAC_SHA384,
            AUTH_ALGORITHM_HMAC_SHA512 => hmac::HMAC_SHA512,
            _ => hmac::HMAC_SHA256,
        };

        let verification_key = hmac::Key::new(algorithm, key);
        hmac::verify(&verification_key, message, received_hmac).is_ok()
    }

    /// Build the Authentication option data
    /// Format (RFC 8415 Section 20.1):
    /// - Protocol (1 byte)
    /// - Algorithm (1 byte)
    /// - RDM (1 byte)
    /// - Replay Detection (8 bytes)
    /// - Authentication Information (variable)
    fn build_auth_option(&mut self, message_without_auth: &[u8]) -> Option<Vec<u8>> {
        if !self.enabled || self.key.is_none() {
            return None;
        }

        let mut auth_data = Vec::new();

        // Protocol
        auth_data.push(self.protocol);

        // Algorithm
        auth_data.push(self.algorithm);

        // RDM (Replay Detection Method)
        auth_data.push(RDM_MONOTONIC_COUNTER);

        // Replay Detection (8 bytes - monotonic counter)
        let replay = self.next_replay_counter();
        auth_data.extend_from_slice(&replay.to_be_bytes());

        // For Delayed Authentication, authentication info contains:
        // - Realm (variable)
        // - Key ID (4 bytes)
        // - HMAC (variable based on algorithm)

        if self.protocol == AUTH_PROTOCOL_DELAYED {
            // Add realm
            if let Some(ref realm) = self.realm {
                auth_data.extend_from_slice(realm.as_bytes());
                auth_data.push(0); // Null terminator
            } else {
                auth_data.push(0); // Empty realm (just null)
            }

            // Add Key ID
            let key_id = self.key_id.unwrap_or(0);
            auth_data.extend_from_slice(&key_id.to_be_bytes());

            // Compute HMAC
            // For HMAC computation, we need to:
            // 1. Build the message with auth option containing zeros for HMAC
            // 2. Compute HMAC over that
            // 3. Replace zeros with actual HMAC

            let hmac_len = self.hmac_length();
            let zeros = vec![0u8; hmac_len];

            // Build temporary auth option with zeros for HMAC
            let mut temp_auth = auth_data.clone();
            temp_auth.extend_from_slice(&zeros);

            // Build full message with this temp auth option
            let mut full_msg = message_without_auth.to_vec();
            // Add auth option header
            full_msg.extend_from_slice(&OPTION_AUTH.to_be_bytes());
            full_msg.extend_from_slice(&(temp_auth.len() as u16).to_be_bytes());
            full_msg.extend_from_slice(&temp_auth);

            // Compute HMAC
            if let Some(hmac) = self.compute_hmac(&full_msg) {
                // Truncate if necessary
                let hmac_to_use = if hmac.len() > hmac_len {
                    &hmac[..hmac_len]
                } else {
                    &hmac
                };
                auth_data.extend_from_slice(hmac_to_use);
            } else {
                return None;
            }
        } else if self.protocol == AUTH_PROTOCOL_RECONFIGURE_KEY {
            // Reconfigure Key authentication
            // Just add the key ID and HMAC
            let key_id = self.key_id.unwrap_or(0);
            auth_data.extend_from_slice(&key_id.to_be_bytes());

            // Compute HMAC over message
            if let Some(hmac) = self.compute_hmac(message_without_auth) {
                auth_data.extend_from_slice(&hmac);
            } else {
                return None;
            }
        }

        Some(auth_data)
    }

    /// Parse and verify Authentication option from received message
    /// Returns (is_valid, replay_counter) if authentication option is present
    fn parse_and_verify_auth(&mut self, message: &[u8], auth_option_data: &[u8]) -> std::result::Result<bool, String> {
        if auth_option_data.len() < 11 {
            return Err("Authentication option too short".to_string());
        }

        let protocol = auth_option_data[0];
        let algorithm = auth_option_data[1];
        let rdm = auth_option_data[2];
        let replay_bytes: [u8; 8] = match auth_option_data[3..11].try_into() {
            Ok(b) => b,
            Err(_) => return Err("Invalid replay detection field".to_string()),
        };
        let replay_counter = u64::from_be_bytes(replay_bytes);

        // Check protocol match
        if protocol != self.protocol {
            return Err(format!("Protocol mismatch: expected {}, got {}", self.protocol, protocol));
        }

        // Check algorithm match
        if algorithm != self.algorithm {
            return Err(format!("Algorithm mismatch: expected {}, got {}", self.algorithm, algorithm));
        }

        // Check RDM
        if rdm != RDM_MONOTONIC_COUNTER {
            return Err(format!("Unsupported RDM: {}", rdm));
        }

        // Check replay counter (must be greater than last seen)
        if let Some(last_counter) = self.server_replay_counter {
            if replay_counter <= last_counter {
                return Err(format!("Replay attack detected: {} <= {}", replay_counter, last_counter));
            }
        }

        // Extract authentication info
        let auth_info = &auth_option_data[11..];

        if self.protocol == AUTH_PROTOCOL_DELAYED {
            // Parse realm, key ID, and HMAC
            // Find null terminator for realm
            let realm_end = match auth_info.iter().position(|&b| b == 0) {
                Some(pos) => pos,
                None => return Err("No realm terminator found".to_string()),
            };

            let _realm = &auth_info[..realm_end];
            let after_realm = &auth_info[realm_end + 1..];

            if after_realm.len() < 4 {
                return Err("Missing key ID".to_string());
            }

            let key_id_bytes: [u8; 4] = match after_realm[..4].try_into() {
                Ok(b) => b,
                Err(_) => return Err("Invalid key ID".to_string()),
            };
            let _key_id = u32::from_be_bytes(key_id_bytes);

            let received_hmac = &after_realm[4..];

            // Verify HMAC
            // Need to reconstruct message with zeros in HMAC field
            let hmac_len = received_hmac.len();

            // Find auth option in original message
            let auth_opt_pos = match self.find_option_position(message, OPTION_AUTH) {
                Some(pos) => pos,
                None => return Err("Cannot find auth option in message".to_string()),
            };

            // Build message with zeros for HMAC
            let mut verify_msg = message.to_vec();
            let hmac_start = auth_opt_pos + 4 + 11 + realm_end + 1 + 4; // option header + protocol+algo+rdm+replay + realm+null + keyid
            if hmac_start + hmac_len <= verify_msg.len() {
                for i in 0..hmac_len {
                    verify_msg[hmac_start + i] = 0;
                }
            }

            if !self.verify_hmac(&verify_msg, received_hmac) {
                return Err("HMAC verification failed".to_string());
            }
        } else {
            // Simple HMAC verification for other protocols
            let received_hmac = auth_info;
            if !self.verify_hmac(message, received_hmac) {
                return Err("HMAC verification failed".to_string());
            }
        }

        // Update replay counter
        self.server_replay_counter = Some(replay_counter);

        Ok(true)
    }

    /// Find option position in message
    fn find_option_position(&self, message: &[u8], option_code: u16) -> Option<usize> {
        if message.len() < 4 {
            return None;
        }

        let mut pos = 4; // Skip message type (1) + transaction ID (3)

        while pos + 4 <= message.len() {
            let opt_code = u16::from_be_bytes([message[pos], message[pos + 1]]);
            let opt_len = u16::from_be_bytes([message[pos + 2], message[pos + 3]]) as usize;

            if opt_code == option_code {
                return Some(pos);
            }

            pos += 4 + opt_len;
        }

        None
    }
}

/// Configuration for DHCPv6 authentication
pub use config::Dhcpv6AuthConfig;

/// Configuration for DHCPv6 TLS
pub use config::Dhcpv6TlsConfig;

/// DHCPv6 TLS Context for STARTTLS support (RFC 7653)
pub struct Dhcpv6TlsContext {
    /// TLS configuration
    config: Dhcpv6TlsConfig,
    /// TLS client configuration (lazy initialized)
    tls_config: Option<Arc<rustls::ClientConfig>>,
    /// Whether TLS has been established
    tls_established: bool,
}

impl std::fmt::Debug for Dhcpv6TlsContext {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Dhcpv6TlsContext")
            .field("enabled", &self.config.enabled)
            .field("tls_established", &self.tls_established)
            .finish()
    }
}

impl Dhcpv6TlsContext {
    /// Create a new TLS context from configuration
    pub fn from_config(config: &Dhcpv6TlsConfig) -> Self {
        Self {
            config: config.clone(),
            tls_config: None,
            tls_established: false,
        }
    }

    /// Check if TLS is enabled
    pub fn is_enabled(&self) -> bool {
        self.config.enabled
    }

    /// Check if TCP should be used
    pub fn use_tcp(&self) -> bool {
        self.config.use_tcp || self.config.enabled
    }

    /// Check if TLS has been established
    pub fn is_tls_established(&self) -> bool {
        self.tls_established
    }

    /// Initialize TLS client configuration
    pub fn init_tls_config(&mut self) -> Result<()> {
        use rustls::ClientConfig;
        use std::fs::File;
        use std::io::BufReader;

        if self.tls_config.is_some() {
            return Ok(());
        }

        let mut root_store = rustls::RootCertStore::empty();

        // Load CA certificates
        if let Some(ref ca_path) = self.config.ca_cert {
            let ca_file = File::open(ca_path)
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to open CA cert file: {}", e)
                ))?;
            let mut ca_reader = BufReader::new(ca_file);
            let certs = rustls_pemfile::certs(&mut ca_reader)
                .collect::<std::result::Result<Vec<_>, _>>()
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to parse CA certs: {}", e)
                ))?;
            for cert in certs {
                root_store.add(cert)
                    .map_err(|e| DhcpClientError::InvalidConfig(
                        format!("Failed to add CA cert: {}", e)
                    ))?;
            }
        } else {
            // Use system root certificates
            root_store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
        }

        let builder = ClientConfig::builder()
            .with_root_certificates(root_store);

        // Configure client certificate if provided (mutual TLS)
        let tls_config = if let (Some(ref cert_path), Some(ref key_path)) =
            (&self.config.client_cert, &self.config.client_key)
        {
            let cert_file = File::open(cert_path)
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to open client cert: {}", e)
                ))?;
            let mut cert_reader = BufReader::new(cert_file);
            let certs = rustls_pemfile::certs(&mut cert_reader)
                .collect::<std::result::Result<Vec<_>, _>>()
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to parse client certs: {}", e)
                ))?;

            let key_file = File::open(key_path)
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to open client key: {}", e)
                ))?;
            let mut key_reader = BufReader::new(key_file);
            let key = rustls_pemfile::private_key(&mut key_reader)
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to parse client key: {}", e)
                ))?
                .ok_or_else(|| DhcpClientError::InvalidConfig(
                    "No private key found in key file".to_string()
                ))?;

            builder.with_client_auth_cert(certs, key)
                .map_err(|e| DhcpClientError::InvalidConfig(
                    format!("Failed to configure client auth: {}", e)
                ))?
        } else {
            builder.with_no_client_auth()
        };

        self.tls_config = Some(Arc::new(tls_config));
        Ok(())
    }

    /// Get TLS client configuration
    pub fn get_tls_config(&self) -> Option<Arc<rustls::ClientConfig>> {
        self.tls_config.clone()
    }

    /// Mark TLS as established
    pub fn set_tls_established(&mut self, established: bool) {
        self.tls_established = established;
    }

    /// Build STARTTLS message (RFC 7653)
    /// Format: msg-type (1 byte) + transaction-id (3 bytes)
    pub fn build_starttls_message(xid: &[u8; 3]) -> Vec<u8> {
        let mut msg = Vec::with_capacity(4);
        msg.push(DHCPV6_STARTTLS);
        msg.extend_from_slice(xid);
        msg
    }

    /// Parse STARTTLS response
    /// Returns true if server accepts STARTTLS
    pub fn parse_starttls_response(data: &[u8], expected_xid: &[u8; 3]) -> bool {
        if data.len() < 4 {
            return false;
        }

        // Check message type is STARTTLS
        if data[0] != DHCPV6_STARTTLS {
            return false;
        }

        // Check transaction ID matches
        &data[1..4] == expected_xid
    }
}

/// TCP connection wrapper for DHCPv6 over TCP
pub struct Dhcpv6TcpConnection {
    stream: Option<tokio::net::TcpStream>,
    tls_stream: Option<tokio_rustls::client::TlsStream<tokio::net::TcpStream>>,
    server_addr: std::net::SocketAddrV6,
}

impl Dhcpv6TcpConnection {
    /// Create a new TCP connection
    pub async fn connect(server_addr: std::net::SocketAddrV6) -> Result<Self> {
        let stream = tokio::net::TcpStream::connect(server_addr).await
            .map_err(|e| DhcpClientError::Network(e))?;

        Ok(Self {
            stream: Some(stream),
            tls_stream: None,
            server_addr,
        })
    }

    /// Perform STARTTLS upgrade
    pub async fn starttls(
        &mut self,
        tls_config: Arc<rustls::ClientConfig>,
        server_name: &str,
    ) -> Result<()> {
        use tokio_rustls::TlsConnector;

        let stream = self.stream.take()
            .ok_or_else(|| DhcpClientError::InvalidConfig(
                "No TCP stream available for TLS upgrade".to_string()
            ))?;

        let server_name = rustls::pki_types::ServerName::try_from(server_name.to_string())
            .map_err(|_| DhcpClientError::InvalidConfig(
                format!("Invalid server name for TLS: {}", server_name)
            ))?;

        let connector = TlsConnector::from(tls_config);
        let tls_stream = connector.connect(server_name, stream).await
            .map_err(|e| DhcpClientError::Network(std::io::Error::new(
                std::io::ErrorKind::ConnectionRefused,
                format!("TLS handshake failed: {}", e)
            )))?;

        self.tls_stream = Some(tls_stream);
        info!("DHCPv6 TLS connection established");
        Ok(())
    }

    /// Send DHCPv6 message over TCP (with or without TLS)
    /// TCP format: 2-byte length prefix + message
    pub async fn send(&mut self, message: &[u8]) -> Result<()> {
        use tokio::io::AsyncWriteExt;

        let len = message.len() as u16;
        let mut buf = Vec::with_capacity(2 + message.len());
        buf.extend_from_slice(&len.to_be_bytes());
        buf.extend_from_slice(message);

        if let Some(ref mut tls_stream) = self.tls_stream {
            tls_stream.write_all(&buf).await
                .map_err(|e| DhcpClientError::Network(e))?;
            tls_stream.flush().await
                .map_err(|e| DhcpClientError::Network(e))?;
        } else if let Some(ref mut stream) = self.stream {
            stream.write_all(&buf).await
                .map_err(|e| DhcpClientError::Network(e))?;
            stream.flush().await
                .map_err(|e| DhcpClientError::Network(e))?;
        } else {
            return Err(DhcpClientError::Network(std::io::Error::new(
                std::io::ErrorKind::NotConnected,
                "No connection available"
            )));
        }

        Ok(())
    }

    /// Receive DHCPv6 message over TCP (with or without TLS)
    pub async fn recv(&mut self, timeout: Duration) -> Result<Vec<u8>> {
        use tokio::io::AsyncReadExt;
        use tokio::time::timeout as tokio_timeout;

        let mut len_buf = [0u8; 2];

        let read_result = if let Some(ref mut tls_stream) = self.tls_stream {
            tokio_timeout(timeout, tls_stream.read_exact(&mut len_buf)).await
        } else if let Some(ref mut stream) = self.stream {
            tokio_timeout(timeout, stream.read_exact(&mut len_buf)).await
        } else {
            return Err(DhcpClientError::Network(std::io::Error::new(
                std::io::ErrorKind::NotConnected,
                "No connection available"
            )));
        };

        match read_result {
            Ok(Ok(_)) => {}
            Ok(Err(e)) => return Err(DhcpClientError::Network(e)),
            Err(_) => return Err(DhcpClientError::Timeout("TCP receive timeout".to_string())),
        }

        let msg_len = u16::from_be_bytes(len_buf) as usize;
        if msg_len > 65535 {
            return Err(DhcpClientError::InvalidMessage(
                format!("Message too large: {} bytes", msg_len)
            ));
        }

        let mut msg_buf = vec![0u8; msg_len];

        let read_result = if let Some(ref mut tls_stream) = self.tls_stream {
            tokio_timeout(timeout, tls_stream.read_exact(&mut msg_buf)).await
        } else if let Some(ref mut stream) = self.stream {
            tokio_timeout(timeout, stream.read_exact(&mut msg_buf)).await
        } else {
            unreachable!()
        };

        match read_result {
            Ok(Ok(_)) => Ok(msg_buf),
            Ok(Err(e)) => Err(DhcpClientError::Network(e)),
            Err(_) => Err(DhcpClientError::Timeout("TCP receive timeout".to_string())),
        }
    }

    /// Check if TLS is active
    pub fn is_tls(&self) -> bool {
        self.tls_stream.is_some()
    }

    /// Close the connection
    pub async fn close(&mut self) {
        use tokio::io::AsyncWriteExt;

        if let Some(ref mut tls_stream) = self.tls_stream {
            let _ = tls_stream.shutdown().await;
        }
        if let Some(ref mut stream) = self.stream {
            let _ = stream.shutdown().await;
        }
        self.tls_stream = None;
        self.stream = None;
    }
}

/// DHCPv6 client
pub struct Dhcpv6Client {
    interface: String,
    mac_address: [u8; 6],
    duid: Vec<u8>,
    state: Arc<RwLock<Dhcpv6State>>,
    config: Dhcpv6Config,
    ia_na: Arc<RwLock<Option<Dhcpv6IaNa>>>,
    ia_pd: Arc<RwLock<Option<Dhcpv6IaPd>>>,
    servers: Arc<RwLock<Vec<DhcpServer>>>,
    security: SecurityContext,
    shutdown: Arc<Mutex<bool>>,
    transaction_id: Arc<Mutex<[u8; 3]>>,
    server_duid: Arc<RwLock<Option<Vec<u8>>>>,
    dns_servers: Arc<RwLock<Vec<Ipv6Addr>>>,
    domain_list: Arc<RwLock<Vec<String>>>,
    iaid: u32,
    /// Authentication context (RFC 8415 Section 20)
    auth_context: Arc<Mutex<Dhcpv6AuthContext>>,
    /// TLS context for STARTTLS (RFC 7653)
    tls_context: Arc<Mutex<Dhcpv6TlsContext>>,
}

impl std::fmt::Debug for Dhcpv6Client {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Dhcpv6Client")
            .field("interface", &self.interface)
            .field("mac_address", &format!("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}",
                self.mac_address[0], self.mac_address[1], self.mac_address[2],
                self.mac_address[3], self.mac_address[4], self.mac_address[5]))
            .finish()
    }
}

impl Dhcpv6Client {
    /// Create a new DHCPv6 client
    pub fn new(interface: &str, config: Dhcpv6Config, security: SecurityConfig) -> Result<Self> {
        // Validate interface name to prevent command injection
        validate_interface_name(interface)?;

        let mac_address = Self::get_mac_address(interface)?;
        let duid = Self::generate_duid(&mac_address);

        // Generate IAID from interface name hash
        let iaid = Self::generate_iaid(interface);

        // Initialize authentication context
        let auth_context = Dhcpv6AuthContext::from_config(&config.authentication);

        // Initialize TLS context
        let tls_context = Dhcpv6TlsContext::from_config(&config.tls);

        Ok(Self {
            interface: interface.to_string(),
            mac_address,
            duid,
            state: Arc::new(RwLock::new(Dhcpv6State::Init)),
            config,
            ia_na: Arc::new(RwLock::new(None)),
            ia_pd: Arc::new(RwLock::new(None)),
            servers: Arc::new(RwLock::new(Vec::new())),
            security: SecurityContext::new(security),
            shutdown: Arc::new(Mutex::new(false)),
            transaction_id: Arc::new(Mutex::new([0u8; 3])),
            server_duid: Arc::new(RwLock::new(None)),
            dns_servers: Arc::new(RwLock::new(Vec::new())),
            domain_list: Arc::new(RwLock::new(Vec::new())),
            iaid,
            auth_context: Arc::new(Mutex::new(auth_context)),
            tls_context: Arc::new(Mutex::new(tls_context)),
        })
    }

    /// Get MAC address for interface
    fn get_mac_address(interface: &str) -> Result<[u8; 6]> {
        use std::fs;

        let mac_path = format!("/sys/class/net/{}/address", interface);

        let mac_str = fs::read_to_string(&mac_path)
            .map_err(|e| DhcpClientError::InterfaceNotFound(
                format!("Failed to read MAC address for {}: {}", interface, e)
            ))?;

        let mac_str = mac_str.trim();
        let parts: Vec<&str> = mac_str.split(':').collect();

        if parts.len() != 6 {
            return Err(DhcpClientError::InterfaceNotFound(
                format!("Invalid MAC address format for interface {}", interface)
            ));
        }

        let mut mac = [0u8; 6];
        for (i, part) in parts.iter().enumerate() {
            mac[i] = u8::from_str_radix(part, 16)
                .map_err(|_| DhcpClientError::InterfaceNotFound(
                    format!("Invalid MAC address for interface {}", interface)
                ))?;
        }

        Ok(mac)
    }

    /// Generate DUID-LLT (Link-layer address plus time)
    fn generate_duid(mac: &[u8; 6]) -> Vec<u8> {
        use std::time::{SystemTime, UNIX_EPOCH};

        let mut duid = Vec::new();

        // DUID Type = 1 (DUID-LLT)
        duid.extend_from_slice(&1u16.to_be_bytes());

        // Hardware type = 1 (Ethernet)
        duid.extend_from_slice(&1u16.to_be_bytes());

        // Time (seconds since Jan 1, 2000 00:00 UTC)
        let epoch_2000 = UNIX_EPOCH + Duration::from_secs(946684800);
        let now = SystemTime::now();
        let time_since = now.duration_since(epoch_2000)
            .unwrap_or(Duration::from_secs(0))
            .as_secs() as u32;
        duid.extend_from_slice(&time_since.to_be_bytes());

        // Link-layer address (MAC)
        duid.extend_from_slice(mac);

        duid
    }

    /// Generate IAID from interface name
    fn generate_iaid(interface: &str) -> u32 {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};

        let mut hasher = DefaultHasher::new();
        interface.hash(&mut hasher);
        hasher.finish() as u32
    }

    /// Get interface name
    pub fn interface(&self) -> &str {
        &self.interface
    }

    /// Get current status
    pub fn get_status(&self) -> Dhcpv6Status {
        let state = self.state.blocking_read();
        let ia_na = self.ia_na.blocking_read();
        let ia_pd = self.ia_pd.blocking_read();
        let servers = self.servers.blocking_read();

        Dhcpv6Status {
            interface: self.interface.clone(),
            state: state.to_string(),
            ia_na: ia_na.as_ref().map(|i| i.to_info()),
            ia_pd: ia_pd.as_ref().map(|i| i.to_info()),
            servers: servers.clone(),
        }
    }

    /// Create DHCPv6 UDP socket bound to the interface
    fn create_socket(&self) -> Result<UdpSocket> {
        // Bind to link-local address on the interface
        let bind_addr = SocketAddrV6::new(
            Ipv6Addr::UNSPECIFIED,
            DHCPV6_CLIENT_PORT,
            0,
            self.get_interface_index()?,
        );

        let socket = UdpSocket::bind(bind_addr)
            .map_err(|e| DhcpClientError::Network(std::io::Error::new(
                std::io::ErrorKind::Other,
                format!("Failed to bind DHCPv6 socket: {}", e)
            )))?;

        // Set socket options
        socket.set_read_timeout(Some(Duration::from_secs(self.config.timeout)))
            .map_err(|e| DhcpClientError::Network(e))?;

        // Join multicast group
        socket.join_multicast_v6(&ALL_DHCP_RELAY_AGENTS_AND_SERVERS, self.get_interface_index()?)
            .map_err(|e| DhcpClientError::Network(std::io::Error::new(
                std::io::ErrorKind::Other,
                format!("Failed to join DHCPv6 multicast group: {}", e)
            )))?;

        dhcpv6_debug!("DHCPv6 socket created on {}", self.interface);
        Ok(socket)
    }

    /// Get interface index
    fn get_interface_index(&self) -> Result<u32> {
        use std::ffi::CString;

        let iface_cstr = CString::new(self.interface.as_str())
            .map_err(|_| DhcpClientError::InvalidInterfaceName(
                "Interface name contains null byte".to_string()
            ))?;

        let index = unsafe { libc::if_nametoindex(iface_cstr.as_ptr()) };

        if index == 0 {
            return Err(DhcpClientError::InterfaceNotFound(
                format!("Interface {} not found", self.interface)
            ));
        }

        Ok(index)
    }

    /// Run the DHCPv6 client
    pub async fn run(&self) -> Result<()> {
        info!("========================================");
        info!("Starting DHCPv6 client on {}", self.interface);
        info!("  DUID: {}", hex::encode(&self.duid));
        info!("  IAID: 0x{:08x}", self.iaid);
        info!("========================================");

        loop {
            // Check if we should shutdown
            if *self.shutdown.lock().await {
                info!("DHCPv6 client shutting down on {}", self.interface);
                break;
            }

            let state = self.state.read().await.clone();
            dhcpv6_debug!("Current state: {}", state);

            match state {
                Dhcpv6State::Init => {
                    dhcpv6_info!("STATE: INIT -> Sending SOLICIT");

                    match self.do_solicit().await {
                        Ok(Some(server_info)) => {
                            dhcpv6_info!("Received ADVERTISE from server");

                            // Store server DUID
                            *self.server_duid.write().await = Some(server_info.server_id.clone());

                            // Send REQUEST
                            match self.do_request(&server_info).await {
                                Ok(true) => {
                                    *self.state.write().await = Dhcpv6State::Bound;
                                    info!("DHCPv6 lease acquired on {}", self.interface);

                                    // Apply the lease
                                    if let Err(e) = self.apply_lease().await {
                                        error!("Failed to apply DHCPv6 lease: {}", e);
                                    }
                                }
                                Ok(false) => {
                                    warn!("REQUEST failed, restarting");
                                    *self.state.write().await = Dhcpv6State::Init;
                                    sleep(Duration::from_secs(self.config.timeout)).await;
                                }
                                Err(e) => {
                                    warn!("REQUEST error: {}", e);
                                    *self.state.write().await = Dhcpv6State::Init;
                                    sleep(Duration::from_secs(self.config.timeout)).await;
                                }
                            }
                        }
                        Ok(None) => {
                            dhcpv6_info!("No ADVERTISE received, retrying");
                            sleep(Duration::from_secs(self.config.timeout)).await;
                        }
                        Err(e) => {
                            warn!("SOLICIT failed: {}", e);
                            sleep(Duration::from_secs(self.config.timeout)).await;
                        }
                    }
                }
                Dhcpv6State::Solicit | Dhcpv6State::Request => {
                    // These are transient states, go back to Init
                    *self.state.write().await = Dhcpv6State::Init;
                }
                Dhcpv6State::Bound => {
                    // Wait for renewal time
                    if let Some(ia_na) = self.ia_na.read().await.as_ref() {
                        let now = SystemTime::now();
                        let renewal_at = ia_na.renewal_at();

                        if now >= renewal_at {
                            dhcpv6_info!("Renewal time reached, transitioning to RENEW");
                            *self.state.write().await = Dhcpv6State::Renew;
                        } else if ia_na.is_expired() {
                            warn!("Lease expired, returning to INIT");
                            *self.ia_na.write().await = None;
                            *self.state.write().await = Dhcpv6State::Init;
                        } else {
                            let wait_time = renewal_at.duration_since(now)
                                .unwrap_or(Duration::from_secs(60));
                            sleep(wait_time.min(Duration::from_secs(60))).await;
                        }
                    } else {
                        // No lease, go back to init
                        *self.state.write().await = Dhcpv6State::Init;
                    }
                }
                Dhcpv6State::Renew => {
                    dhcpv6_info!("STATE: RENEW");

                    match self.do_renew().await {
                        Ok(true) => {
                            dhcpv6_info!("Renewal successful");
                            *self.state.write().await = Dhcpv6State::Bound;

                            if let Err(e) = self.apply_lease().await {
                                warn!("Failed to apply renewed lease: {}", e);
                            }
                        }
                        Ok(false) | Err(_) => {
                            // Check if we should rebind
                            if let Some(ia_na) = self.ia_na.read().await.as_ref() {
                                let now = SystemTime::now();
                                if now >= ia_na.rebinding_at() {
                                    dhcpv6_info!("Rebinding time reached, transitioning to REBIND");
                                    *self.state.write().await = Dhcpv6State::Rebind;
                                } else {
                                    // Retry renew
                                    sleep(Duration::from_secs(self.config.timeout)).await;
                                }
                            } else {
                                *self.state.write().await = Dhcpv6State::Init;
                            }
                        }
                    }
                }
                Dhcpv6State::Rebind => {
                    dhcpv6_info!("STATE: REBIND");

                    match self.do_rebind().await {
                        Ok(true) => {
                            dhcpv6_info!("Rebind successful");
                            *self.state.write().await = Dhcpv6State::Bound;

                            if let Err(e) = self.apply_lease().await {
                                warn!("Failed to apply rebound lease: {}", e);
                            }
                        }
                        Ok(false) | Err(_) => {
                            // Check if lease expired
                            if let Some(ia_na) = self.ia_na.read().await.as_ref() {
                                if ia_na.is_expired() {
                                    warn!("Lease expired during rebind, returning to INIT");
                                    *self.ia_na.write().await = None;
                                    *self.state.write().await = Dhcpv6State::Init;
                                } else {
                                    sleep(Duration::from_secs(self.config.timeout)).await;
                                }
                            } else {
                                *self.state.write().await = Dhcpv6State::Init;
                            }
                        }
                    }
                }
                Dhcpv6State::Confirm => {
                    // Confirm is used after link reconnection
                    // For now, just go to Bound
                    *self.state.write().await = Dhcpv6State::Bound;
                }
            }

            // Small sleep to avoid busy loop
            sleep(Duration::from_millis(100)).await;
        }

        Ok(())
    }

    /// Send SOLICIT and wait for ADVERTISE
    async fn do_solicit(&self) -> Result<Option<Dhcpv6ServerInfo>> {
        self.security.check_rate_limit(&self.interface).await?;

        // Generate new transaction ID
        let xid: [u8; 3] = rand::random();
        *self.transaction_id.lock().await = xid;

        dhcpv6_info!("Sending DHCPv6 SOLICIT (xid: {:02x}{:02x}{:02x})", xid[0], xid[1], xid[2]);

        // Build SOLICIT message
        let solicit = self.build_solicit_message(&xid);

        // Create socket and send
        let socket = self.create_socket()?;

        let dest = SocketAddrV6::new(
            ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
            DHCPV6_SERVER_PORT,
            0,
            self.get_interface_index()?,
        );

        socket.send_to(&solicit, dest)
            .map_err(|e| DhcpClientError::Network(e))?;

        info!("DHCPv6 SOLICIT sent on {}", self.interface);

        // Wait for ADVERTISE
        let mut buf = [0u8; 1500];
        let timeout = Duration::from_secs(self.config.timeout);
        let start = std::time::Instant::now();

        while start.elapsed() < timeout {
            match socket.recv_from(&mut buf) {
                Ok((size, _src)) => {
                    dhcpv6_debug!("Received {} bytes from {}", size, _src);

                    if let Some(server_info) = self.parse_advertise(&buf[..size], &xid) {
                        dhcpv6_info!("Received valid ADVERTISE");
                        return Ok(Some(server_info));
                    }
                }
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    continue;
                }
                Err(e) if e.kind() == std::io::ErrorKind::TimedOut => {
                    break;
                }
                Err(_e) => {
                    dhcpv6_debug!("Recv error: {}", _e);
                }
            }
        }

        Ok(None)
    }

    /// Send REQUEST and wait for REPLY
    async fn do_request(&self, server_info: &Dhcpv6ServerInfo) -> Result<bool> {
        self.security.check_rate_limit(&self.interface).await?;

        let xid: [u8; 3] = rand::random();
        *self.transaction_id.lock().await = xid;

        dhcpv6_info!("Sending DHCPv6 REQUEST");

        let request = self.build_request_message(&xid, server_info);

        let socket = self.create_socket()?;

        let dest = SocketAddrV6::new(
            ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
            DHCPV6_SERVER_PORT,
            0,
            self.get_interface_index()?,
        );

        socket.send_to(&request, dest)
            .map_err(|e| DhcpClientError::Network(e))?;

        info!("DHCPv6 REQUEST sent on {}", self.interface);

        // Wait for REPLY
        let mut buf = [0u8; 1500];
        let timeout = Duration::from_secs(self.config.timeout);
        let start = std::time::Instant::now();

        while start.elapsed() < timeout {
            match socket.recv_from(&mut buf) {
                Ok((size, _src)) => {
                    if let Some((ia_na, ia_pd, dns, domains)) = self.parse_reply(&buf[..size], &xid) {
                        dhcpv6_info!("Received valid REPLY");

                        // Store lease information
                        if let Some(ia_na) = ia_na {
                            *self.ia_na.write().await = Some(ia_na);
                        }
                        if let Some(ia_pd) = ia_pd {
                            *self.ia_pd.write().await = Some(ia_pd);
                        }
                        *self.dns_servers.write().await = dns;
                        *self.domain_list.write().await = domains;

                        return Ok(true);
                    }
                }
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
                Err(e) if e.kind() == std::io::ErrorKind::TimedOut => break,
                Err(_) => {}
            }
        }

        Ok(false)
    }

    /// Send RENEW message (unicast to server)
    async fn do_renew(&self) -> Result<bool> {
        self.security.check_rate_limit(&self.interface).await?;

        let xid: [u8; 3] = rand::random();
        *self.transaction_id.lock().await = xid;

        let server_duid = self.server_duid.read().await.clone()
            .ok_or_else(|| DhcpClientError::NoLease)?;

        dhcpv6_info!("Sending DHCPv6 RENEW");

        let renew = self.build_renew_message(&xid, &server_duid);

        let socket = self.create_socket()?;

        // RENEW is sent to multicast (could be unicast if server allows)
        let dest = SocketAddrV6::new(
            ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
            DHCPV6_SERVER_PORT,
            0,
            self.get_interface_index()?,
        );

        socket.send_to(&renew, dest)
            .map_err(|e| DhcpClientError::Network(e))?;

        // Wait for REPLY
        let mut buf = [0u8; 1500];
        let timeout = Duration::from_secs(self.config.timeout);
        let start = std::time::Instant::now();

        while start.elapsed() < timeout {
            match socket.recv_from(&mut buf) {
                Ok((size, _)) => {
                    if let Some((ia_na, ia_pd, dns, domains)) = self.parse_reply(&buf[..size], &xid) {
                        if let Some(ia_na) = ia_na {
                            *self.ia_na.write().await = Some(ia_na);
                        }
                        if let Some(ia_pd) = ia_pd {
                            *self.ia_pd.write().await = Some(ia_pd);
                        }
                        *self.dns_servers.write().await = dns;
                        *self.domain_list.write().await = domains;
                        return Ok(true);
                    }
                }
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
                Err(e) if e.kind() == std::io::ErrorKind::TimedOut => break,
                Err(_) => {}
            }
        }

        Ok(false)
    }

    /// Send REBIND message (multicast)
    async fn do_rebind(&self) -> Result<bool> {
        self.security.check_rate_limit(&self.interface).await?;

        let xid: [u8; 3] = rand::random();
        *self.transaction_id.lock().await = xid;

        dhcpv6_info!("Sending DHCPv6 REBIND");

        let rebind = self.build_rebind_message(&xid);

        let socket = self.create_socket()?;

        let dest = SocketAddrV6::new(
            ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
            DHCPV6_SERVER_PORT,
            0,
            self.get_interface_index()?,
        );

        socket.send_to(&rebind, dest)
            .map_err(|e| DhcpClientError::Network(e))?;

        // Wait for REPLY
        let mut buf = [0u8; 1500];
        let timeout = Duration::from_secs(self.config.timeout);
        let start = std::time::Instant::now();

        while start.elapsed() < timeout {
            match socket.recv_from(&mut buf) {
                Ok((size, _)) => {
                    if let Some((ia_na, ia_pd, dns, domains)) = self.parse_reply(&buf[..size], &xid) {
                        if let Some(ia_na) = ia_na {
                            *self.ia_na.write().await = Some(ia_na);
                        }
                        if let Some(ia_pd) = ia_pd {
                            *self.ia_pd.write().await = Some(ia_pd);
                        }
                        *self.dns_servers.write().await = dns;
                        *self.domain_list.write().await = domains;
                        return Ok(true);
                    }
                }
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
                Err(e) if e.kind() == std::io::ErrorKind::TimedOut => break,
                Err(_) => {}
            }
        }

        Ok(false)
    }

    /// Build SOLICIT message
    fn build_solicit_message(&self, xid: &[u8; 3]) -> Vec<u8> {
        let mut msg = Vec::new();

        // Message type (1 byte) + Transaction ID (3 bytes)
        msg.push(DHCPV6_SOLICIT);
        msg.extend_from_slice(xid);

        // Option: Client Identifier (DUID)
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Option: Elapsed Time (initially 0)
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // Option: IA_NA (Identity Association for Non-temporary Addresses)
        let ia_na_data = self.build_ia_na_option(None);
        self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);

        // Option: IA_PD if prefix delegation enabled
        if self.config.prefix_delegation {
            let ia_pd_data = self.build_ia_pd_option(None);
            self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
        }

        // Option: Option Request (ORO)
        let mut oro_data = Vec::new();
        for opt in &self.config.request_options {
            oro_data.extend_from_slice(&opt.to_be_bytes());
        }
        // Always request DNS servers and domain list
        if !self.config.request_options.contains(&OPTION_DNS_SERVERS) {
            oro_data.extend_from_slice(&OPTION_DNS_SERVERS.to_be_bytes());
        }
        if !self.config.request_options.contains(&OPTION_DOMAIN_LIST) {
            oro_data.extend_from_slice(&OPTION_DOMAIN_LIST.to_be_bytes());
        }
        self.add_option(&mut msg, OPTION_ORO, &oro_data);

        // Option: Rapid Commit (if enabled)
        if self.config.rapid_commit {
            self.add_option(&mut msg, OPTION_RAPID_COMMIT, &[]);
        }

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build REQUEST message
    fn build_request_message(&self, xid: &[u8; 3], server_info: &Dhcpv6ServerInfo) -> Vec<u8> {
        let mut msg = Vec::new();

        msg.push(DHCPV6_REQUEST);
        msg.extend_from_slice(xid);

        // Client ID
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Server ID
        self.add_option(&mut msg, OPTION_SERVERID, &server_info.server_id);

        // Elapsed Time
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // IA_NA with addresses from ADVERTISE
        if let Some(ref ia_na) = server_info.ia_na {
            let ia_na_data = self.build_ia_na_option(Some(ia_na));
            self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);
        } else {
            let ia_na_data = self.build_ia_na_option(None);
            self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);
        }

        // IA_PD if enabled
        if self.config.prefix_delegation {
            if let Some(ref ia_pd) = server_info.ia_pd {
                let ia_pd_data = self.build_ia_pd_option(Some(ia_pd));
                self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
            } else {
                let ia_pd_data = self.build_ia_pd_option(None);
                self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
            }
        }

        // ORO
        let mut oro_data = Vec::new();
        oro_data.extend_from_slice(&OPTION_DNS_SERVERS.to_be_bytes());
        oro_data.extend_from_slice(&OPTION_DOMAIN_LIST.to_be_bytes());
        self.add_option(&mut msg, OPTION_ORO, &oro_data);

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build RENEW message
    fn build_renew_message(&self, xid: &[u8; 3], server_duid: &[u8]) -> Vec<u8> {
        let mut msg = Vec::new();

        msg.push(DHCPV6_RENEW);
        msg.extend_from_slice(xid);

        // Client ID
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Server ID
        self.add_option(&mut msg, OPTION_SERVERID, server_duid);

        // Elapsed Time
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // Include current IA_NA
        if let Some(ref ia_na) = *self.ia_na.blocking_read() {
            let ia_na_data = self.build_ia_na_option(Some(ia_na));
            self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);
        }

        // Include current IA_PD
        if self.config.prefix_delegation {
            if let Some(ref ia_pd) = *self.ia_pd.blocking_read() {
                let ia_pd_data = self.build_ia_pd_option(Some(ia_pd));
                self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
            }
        }

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build REBIND message
    fn build_rebind_message(&self, xid: &[u8; 3]) -> Vec<u8> {
        let mut msg = Vec::new();

        msg.push(DHCPV6_REBIND);
        msg.extend_from_slice(xid);

        // Client ID
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Elapsed Time
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // Include current IA_NA
        if let Some(ref ia_na) = *self.ia_na.blocking_read() {
            let ia_na_data = self.build_ia_na_option(Some(ia_na));
            self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);
        }

        // Include current IA_PD
        if self.config.prefix_delegation {
            if let Some(ref ia_pd) = *self.ia_pd.blocking_read() {
                let ia_pd_data = self.build_ia_pd_option(Some(ia_pd));
                self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
            }
        }

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build RELEASE message
    fn build_release_message(&self, xid: &[u8; 3], server_duid: &[u8]) -> Vec<u8> {
        let mut msg = Vec::new();

        msg.push(DHCPV6_RELEASE);
        msg.extend_from_slice(xid);

        // Client ID
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Server ID
        self.add_option(&mut msg, OPTION_SERVERID, server_duid);

        // Elapsed Time
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // Include IA_NA being released
        if let Some(ref ia_na) = *self.ia_na.blocking_read() {
            let ia_na_data = self.build_ia_na_option(Some(ia_na));
            self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);
        }

        // Include IA_PD being released
        if let Some(ref ia_pd) = *self.ia_pd.blocking_read() {
            let ia_pd_data = self.build_ia_pd_option(Some(ia_pd));
            self.add_option(&mut msg, OPTION_IA_PD, &ia_pd_data);
        }

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build DECLINE message
    fn build_decline_message(&self, xid: &[u8; 3], server_duid: &[u8], addresses: &[Ipv6Addr]) -> Vec<u8> {
        let mut msg = Vec::new();

        msg.push(DHCPV6_DECLINE);
        msg.extend_from_slice(xid);

        // Client ID
        self.add_option(&mut msg, OPTION_CLIENTID, &self.duid);

        // Server ID
        self.add_option(&mut msg, OPTION_SERVERID, server_duid);

        // Elapsed Time
        self.add_option(&mut msg, OPTION_ELAPSED_TIME, &[0, 0]);

        // IA_NA with addresses being declined
        let mut ia_na_data = Vec::new();
        ia_na_data.extend_from_slice(&self.iaid.to_be_bytes());  // IAID
        ia_na_data.extend_from_slice(&0u32.to_be_bytes());  // T1
        ia_na_data.extend_from_slice(&0u32.to_be_bytes());  // T2

        for addr in addresses {
            let mut iaaddr = Vec::new();
            iaaddr.extend_from_slice(&addr.octets());  // Address
            iaaddr.extend_from_slice(&0u32.to_be_bytes());  // Preferred lifetime
            iaaddr.extend_from_slice(&0u32.to_be_bytes());  // Valid lifetime

            // Add IAADDR option to IA_NA
            ia_na_data.extend_from_slice(&OPTION_IAADDR.to_be_bytes());
            ia_na_data.extend_from_slice(&(iaaddr.len() as u16).to_be_bytes());
            ia_na_data.extend_from_slice(&iaaddr);
        }

        self.add_option(&mut msg, OPTION_IA_NA, &ia_na_data);

        // Add authentication option (must be last)
        self.add_auth_option_blocking(&mut msg);

        msg
    }

    /// Build IA_NA option data
    fn build_ia_na_option(&self, existing: Option<&Dhcpv6IaNa>) -> Vec<u8> {
        let mut data = Vec::new();

        // IAID (4 bytes)
        let iaid = existing.map(|i| i.iaid).unwrap_or(self.iaid);
        data.extend_from_slice(&iaid.to_be_bytes());

        // T1 (4 bytes)
        let t1 = existing.map(|i| i.t1.as_secs() as u32).unwrap_or(0);
        data.extend_from_slice(&t1.to_be_bytes());

        // T2 (4 bytes)
        let t2 = existing.map(|i| i.t2.as_secs() as u32).unwrap_or(0);
        data.extend_from_slice(&t2.to_be_bytes());

        // Include IAADDR options if we have addresses
        if let Some(ia_na) = existing {
            for addr in &ia_na.addresses {
                let mut iaaddr = Vec::new();
                iaaddr.extend_from_slice(&addr.octets());
                iaaddr.extend_from_slice(&(ia_na.preferred_lifetime.as_secs() as u32).to_be_bytes());
                iaaddr.extend_from_slice(&(ia_na.valid_lifetime.as_secs() as u32).to_be_bytes());

                data.extend_from_slice(&OPTION_IAADDR.to_be_bytes());
                data.extend_from_slice(&(iaaddr.len() as u16).to_be_bytes());
                data.extend_from_slice(&iaaddr);
            }
        }

        data
    }

    /// Build IA_PD option data
    fn build_ia_pd_option(&self, existing: Option<&Dhcpv6IaPd>) -> Vec<u8> {
        let mut data = Vec::new();

        // IAID (4 bytes) - use different IAID for PD
        let iaid = existing.map(|i| i.iaid).unwrap_or(self.iaid.wrapping_add(1));
        data.extend_from_slice(&iaid.to_be_bytes());

        // T1 (4 bytes)
        let t1 = existing.map(|i| i.t1.as_secs() as u32).unwrap_or(0);
        data.extend_from_slice(&t1.to_be_bytes());

        // T2 (4 bytes)
        let t2 = existing.map(|i| i.t2.as_secs() as u32).unwrap_or(0);
        data.extend_from_slice(&t2.to_be_bytes());

        // Include IAPREFIX option if we have a prefix
        if let Some(ia_pd) = existing {
            let mut iaprefix = Vec::new();
            iaprefix.extend_from_slice(&(ia_pd.preferred_lifetime.as_secs() as u32).to_be_bytes());
            iaprefix.extend_from_slice(&(ia_pd.valid_lifetime.as_secs() as u32).to_be_bytes());
            iaprefix.push(ia_pd.prefix_len);
            iaprefix.extend_from_slice(&ia_pd.prefix.octets());

            data.extend_from_slice(&OPTION_IAPREFIX.to_be_bytes());
            data.extend_from_slice(&(iaprefix.len() as u16).to_be_bytes());
            data.extend_from_slice(&iaprefix);
        }

        data
    }

    /// Add an option to the message
    fn add_option(&self, msg: &mut Vec<u8>, code: u16, data: &[u8]) {
        msg.extend_from_slice(&code.to_be_bytes());
        msg.extend_from_slice(&(data.len() as u16).to_be_bytes());
        msg.extend_from_slice(data);
    }

    /// Add authentication option to a message (async version)
    /// This must be called last, after all other options are added
    async fn add_auth_option(&self, msg: &mut Vec<u8>) {
        let mut auth_ctx = self.auth_context.lock().await;
        if !auth_ctx.enabled {
            return;
        }

        // Build authentication option with HMAC computed over the message
        if let Some(auth_data) = auth_ctx.build_auth_option(msg) {
            self.add_option(msg, OPTION_AUTH, &auth_data);
            dhcpv6_debug!("Added authentication option ({} bytes)", auth_data.len());
        }
    }

    /// Add authentication option to a message (blocking version for sync contexts)
    fn add_auth_option_blocking(&self, msg: &mut Vec<u8>) {
        let mut auth_ctx = self.auth_context.blocking_lock();
        if !auth_ctx.enabled {
            return;
        }

        // Build authentication option with HMAC computed over the message
        if let Some(auth_data) = auth_ctx.build_auth_option(msg) {
            self.add_option(msg, OPTION_AUTH, &auth_data);
            dhcpv6_debug!("Added authentication option ({} bytes)", auth_data.len());
        }
    }

    /// Verify authentication on a received message
    /// Returns Ok(true) if authentication verified, Ok(false) if no auth required/present,
    /// Err if authentication failed
    async fn verify_message_auth(&self, message: &[u8]) -> Result<bool> {
        let mut auth_ctx = self.auth_context.lock().await;

        if !auth_ctx.enabled {
            return Ok(false);
        }

        // Find authentication option in message
        if let Some(auth_opt_data) = self.extract_auth_option(message) {
            match auth_ctx.parse_and_verify_auth(message, &auth_opt_data) {
                Ok(true) => {
                    dhcpv6_debug!("Authentication verified successfully");
                    Ok(true)
                }
                Ok(false) => {
                    warn!("Authentication verification returned false");
                    if auth_ctx.require_server_auth {
                        Err(DhcpClientError::SecurityViolation(
                            "Server authentication failed".to_string()
                        ))
                    } else {
                        Ok(false)
                    }
                }
                Err(e) => {
                    warn!("Authentication verification error: {}", e);
                    if auth_ctx.require_server_auth {
                        Err(DhcpClientError::SecurityViolation(
                            format!("Server authentication error: {}", e)
                        ))
                    } else {
                        Ok(false)
                    }
                }
            }
        } else {
            // No authentication option in message
            if auth_ctx.require_server_auth && !auth_ctx.accept_unauthenticated {
                Err(DhcpClientError::SecurityViolation(
                    "Server message has no authentication".to_string()
                ))
            } else {
                dhcpv6_debug!("No authentication option in server message");
                Ok(false)
            }
        }
    }

    /// Extract authentication option data from message
    fn extract_auth_option(&self, message: &[u8]) -> Option<Vec<u8>> {
        if message.len() < 4 {
            return None;
        }

        let mut pos = 4; // Skip message type (1) + transaction ID (3)

        while pos + 4 <= message.len() {
            let opt_code = u16::from_be_bytes([message[pos], message[pos + 1]]);
            let opt_len = u16::from_be_bytes([message[pos + 2], message[pos + 3]]) as usize;

            if pos + 4 + opt_len > message.len() {
                break;
            }

            if opt_code == OPTION_AUTH {
                return Some(message[pos + 4..pos + 4 + opt_len].to_vec());
            }

            pos += 4 + opt_len;
        }

        None
    }

    /// Parse ADVERTISE message
    fn parse_advertise(&self, data: &[u8], expected_xid: &[u8; 3]) -> Option<Dhcpv6ServerInfo> {
        if data.len() < 4 {
            return None;
        }

        // Check message type
        if data[0] != DHCPV6_ADVERTISE {
            return None;
        }

        // Check transaction ID
        if &data[1..4] != expected_xid {
            dhcpv6_debug!("XID mismatch in ADVERTISE");
            return None;
        }

        // Parse options
        let mut server_id: Option<Vec<u8>> = None;
        let mut preference: u8 = 0;
        let mut ia_na: Option<Dhcpv6IaNa> = None;
        let mut ia_pd: Option<Dhcpv6IaPd> = None;
        let mut dns_servers: Vec<Ipv6Addr> = Vec::new();
        let mut domain_list: Vec<String> = Vec::new();

        let mut i = 4;
        while i + 4 <= data.len() {
            let opt_code = u16::from_be_bytes([data[i], data[i + 1]]);
            let opt_len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
            i += 4;

            if i + opt_len > data.len() {
                break;
            }

            let opt_data = &data[i..i + opt_len];

            match opt_code {
                OPTION_SERVERID => {
                    server_id = Some(opt_data.to_vec());
                }
                OPTION_PREFERENCE => {
                    if opt_len >= 1 {
                        preference = opt_data[0];
                    }
                }
                OPTION_IA_NA => {
                    ia_na = self.parse_ia_na(opt_data);
                }
                OPTION_IA_PD => {
                    ia_pd = self.parse_ia_pd(opt_data);
                }
                OPTION_DNS_SERVERS => {
                    dns_servers = self.parse_dns_servers(opt_data);
                }
                OPTION_DOMAIN_LIST => {
                    domain_list = self.parse_domain_list(opt_data);
                }
                OPTION_STATUS_CODE => {
                    if opt_len >= 2 {
                        let status = u16::from_be_bytes([opt_data[0], opt_data[1]]);
                        if status != STATUS_SUCCESS {
                            dhcpv6_debug!("ADVERTISE contains error status: {}", status);
                            return None;
                        }
                    }
                }
                _ => {
                    dhcpv6_debug!("Unknown option {} (len {})", opt_code, opt_len);
                }
            }

            i += opt_len;
        }

        let server_id = server_id?;

        Some(Dhcpv6ServerInfo {
            server_id,
            address: Ipv6Addr::UNSPECIFIED,  // Will be filled from socket
            preference,
            ia_na,
            ia_pd,
            dns_servers,
            domain_list,
        })
    }

    /// Parse REPLY message
    fn parse_reply(&self, data: &[u8], expected_xid: &[u8; 3]) -> Option<(Option<Dhcpv6IaNa>, Option<Dhcpv6IaPd>, Vec<Ipv6Addr>, Vec<String>)> {
        if data.len() < 4 {
            return None;
        }

        if data[0] != DHCPV6_REPLY {
            return None;
        }

        if &data[1..4] != expected_xid {
            dhcpv6_debug!("XID mismatch in REPLY");
            return None;
        }

        let mut ia_na: Option<Dhcpv6IaNa> = None;
        let mut ia_pd: Option<Dhcpv6IaPd> = None;
        let mut dns_servers: Vec<Ipv6Addr> = Vec::new();
        let mut domain_list: Vec<String> = Vec::new();
        let mut status_ok = true;

        let mut i = 4;
        while i + 4 <= data.len() {
            let opt_code = u16::from_be_bytes([data[i], data[i + 1]]);
            let opt_len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
            i += 4;

            if i + opt_len > data.len() {
                break;
            }

            let opt_data = &data[i..i + opt_len];

            match opt_code {
                OPTION_IA_NA => {
                    ia_na = self.parse_ia_na(opt_data);
                }
                OPTION_IA_PD => {
                    ia_pd = self.parse_ia_pd(opt_data);
                }
                OPTION_DNS_SERVERS => {
                    dns_servers = self.parse_dns_servers(opt_data);
                }
                OPTION_DOMAIN_LIST => {
                    domain_list = self.parse_domain_list(opt_data);
                }
                OPTION_STATUS_CODE => {
                    if opt_len >= 2 {
                        let status = u16::from_be_bytes([opt_data[0], opt_data[1]]);
                        if status != STATUS_SUCCESS {
                            warn!("REPLY contains error status: {}", status);
                            status_ok = false;
                        }
                    }
                }
                _ => {}
            }

            i += opt_len;
        }

        if !status_ok {
            return None;
        }

        Some((ia_na, ia_pd, dns_servers, domain_list))
    }

    /// Parse IA_NA option
    fn parse_ia_na(&self, data: &[u8]) -> Option<Dhcpv6IaNa> {
        if data.len() < 12 {
            return None;
        }

        let iaid = u32::from_be_bytes([data[0], data[1], data[2], data[3]]);
        let t1 = u32::from_be_bytes([data[4], data[5], data[6], data[7]]);
        let t2 = u32::from_be_bytes([data[8], data[9], data[10], data[11]]);

        let mut addresses = Vec::new();
        let mut preferred_lifetime = Duration::from_secs(0);
        let mut valid_lifetime = Duration::from_secs(0);

        // Parse sub-options (IAADDR)
        let mut i = 12;
        while i + 4 <= data.len() {
            let opt_code = u16::from_be_bytes([data[i], data[i + 1]]);
            let opt_len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
            i += 4;

            if i + opt_len > data.len() {
                break;
            }

            if opt_code == OPTION_IAADDR && opt_len >= 24 {
                let addr_bytes: [u8; 16] = data[i..i + 16].try_into().ok()?;
                let addr = Ipv6Addr::from(addr_bytes);
                preferred_lifetime = Duration::from_secs(
                    u32::from_be_bytes([data[i + 16], data[i + 17], data[i + 18], data[i + 19]]) as u64
                );
                valid_lifetime = Duration::from_secs(
                    u32::from_be_bytes([data[i + 20], data[i + 21], data[i + 22], data[i + 23]]) as u64
                );
                addresses.push(addr);
            }

            i += opt_len;
        }

        if addresses.is_empty() {
            return None;
        }

        Some(Dhcpv6IaNa {
            iaid,
            addresses,
            t1: Duration::from_secs(t1 as u64),
            t2: Duration::from_secs(t2 as u64),
            preferred_lifetime,
            valid_lifetime,
            acquired_at: SystemTime::now(),
        })
    }

    /// Parse IA_PD option
    fn parse_ia_pd(&self, data: &[u8]) -> Option<Dhcpv6IaPd> {
        if data.len() < 12 {
            return None;
        }

        let iaid = u32::from_be_bytes([data[0], data[1], data[2], data[3]]);
        let t1 = u32::from_be_bytes([data[4], data[5], data[6], data[7]]);
        let t2 = u32::from_be_bytes([data[8], data[9], data[10], data[11]]);

        // Parse sub-options (IAPREFIX)
        let mut i = 12;
        while i + 4 <= data.len() {
            let opt_code = u16::from_be_bytes([data[i], data[i + 1]]);
            let opt_len = u16::from_be_bytes([data[i + 2], data[i + 3]]) as usize;
            i += 4;

            if i + opt_len > data.len() {
                break;
            }

            if opt_code == OPTION_IAPREFIX && opt_len >= 25 {
                let preferred_lifetime = Duration::from_secs(
                    u32::from_be_bytes([data[i], data[i + 1], data[i + 2], data[i + 3]]) as u64
                );
                let valid_lifetime = Duration::from_secs(
                    u32::from_be_bytes([data[i + 4], data[i + 5], data[i + 6], data[i + 7]]) as u64
                );
                let prefix_len = data[i + 8];
                let prefix_bytes: [u8; 16] = data[i + 9..i + 25].try_into().ok()?;
                let prefix = Ipv6Addr::from(prefix_bytes);

                return Some(Dhcpv6IaPd {
                    iaid,
                    prefix,
                    prefix_len,
                    t1: Duration::from_secs(t1 as u64),
                    t2: Duration::from_secs(t2 as u64),
                    preferred_lifetime,
                    valid_lifetime,
                    acquired_at: SystemTime::now(),
                });
            }

            i += opt_len;
        }

        None
    }

    /// Parse DNS servers option
    fn parse_dns_servers(&self, data: &[u8]) -> Vec<Ipv6Addr> {
        let mut servers = Vec::new();
        let mut i = 0;

        while i + 16 <= data.len() {
            let addr_bytes: [u8; 16] = data[i..i + 16].try_into().unwrap();
            servers.push(Ipv6Addr::from(addr_bytes));
            i += 16;
        }

        servers
    }

    /// Parse domain search list
    fn parse_domain_list(&self, data: &[u8]) -> Vec<String> {
        // Domain list uses DNS wire format (length-prefixed labels)
        let mut domains = Vec::new();
        let mut i = 0;

        while i < data.len() {
            let mut labels = Vec::new();

            loop {
                if i >= data.len() {
                    break;
                }

                let len = data[i] as usize;
                i += 1;

                if len == 0 {
                    break;
                }

                if i + len > data.len() {
                    break;
                }

                if let Ok(label) = std::str::from_utf8(&data[i..i + len]) {
                    labels.push(label.to_string());
                }
                i += len;
            }

            if !labels.is_empty() {
                domains.push(labels.join("."));
            }
        }

        domains
    }

    /// Apply lease to interface
    async fn apply_lease(&self) -> Result<()> {
        use tokio::process::Command;

        let ia_na = self.ia_na.read().await;
        let dns_servers = self.dns_servers.read().await;

        if let Some(ref ia_na) = *ia_na {
            for addr in &ia_na.addresses {
                info!("Configuring IPv6 address {} on {}", addr, self.interface);

                // Add IPv6 address
                let output = Command::new("ip")
                    .args(&["-6", "addr", "add", &format!("{}/128", addr), "dev", &self.interface])
                    .output()
                    .await
                    .map_err(|e| DhcpClientError::Network(e))?;

                if !output.status.success() {
                    let stderr = String::from_utf8_lossy(&output.stderr);
                    if !stderr.contains("File exists") {
                        warn!("Failed to add IPv6 address: {}", stderr);
                    }
                }
            }
        }

        // Update DNS configuration
        if !dns_servers.is_empty() {
            if let Err(e) = self.update_resolv_conf(&dns_servers).await {
                warn!("Failed to update resolv.conf: {}", e);
            }
        }

        info!("✓ DHCPv6 lease applied on {}", self.interface);
        Ok(())
    }

    /// Update /etc/resolv.conf with IPv6 DNS servers
    async fn update_resolv_conf(&self, dns_servers: &[Ipv6Addr]) -> Result<()> {
        use tokio::fs;

        // Read existing content
        let existing = fs::read_to_string("/etc/resolv.conf").await.unwrap_or_default();

        // Filter out old IPv6 nameservers (we'll add new ones)
        let lines: Vec<&str> = existing.lines()
            .filter(|line| {
                if line.starts_with("nameserver ") {
                    let addr = line.trim_start_matches("nameserver ").trim();
                    // Keep IPv4 nameservers
                    !addr.contains(':')
                } else {
                    true
                }
            })
            .collect();

        // Add new IPv6 nameservers
        let mut new_content = String::new();
        new_content.push_str(&format!("# DHCPv6 DNS servers for {}\n", self.interface));
        for dns in dns_servers {
            new_content.push_str(&format!("nameserver {}\n", dns));
        }
        for line in &lines {
            new_content.push_str(line);
            new_content.push('\n');
        }

        // Write atomically
        let temp_path = "/etc/resolv.conf.dhcpv6.tmp";
        fs::write(temp_path, &new_content).await
            .map_err(|e| DhcpClientError::Network(e))?;
        fs::rename(temp_path, "/etc/resolv.conf").await
            .map_err(|e| DhcpClientError::Network(e))?;

        info!("✓ Updated /etc/resolv.conf with {} IPv6 DNS servers", dns_servers.len());
        Ok(())
    }

    /// Renew lease
    pub async fn renew(&self) -> Result<()> {
        info!("Renewing DHCPv6 lease on {}", self.interface);
        *self.state.write().await = Dhcpv6State::Renew;
        Ok(())
    }

    /// Release lease
    pub async fn release(&self) -> Result<()> {
        info!("Releasing DHCPv6 lease on {}", self.interface);

        // Send RELEASE message if we have a server DUID
        if let Some(ref server_duid) = *self.server_duid.read().await {
            let xid: [u8; 3] = rand::random();
            let release = self.build_release_message(&xid, server_duid);

            if let Ok(socket) = self.create_socket() {
                let dest = SocketAddrV6::new(
                    ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
                    DHCPV6_SERVER_PORT,
                    0,
                    self.get_interface_index().unwrap_or(0),
                );

                let _ = socket.send_to(&release, dest);
                info!("DHCPv6 RELEASE sent on {}", self.interface);
            }
        }

        // Clear state
        *self.ia_na.write().await = None;
        *self.ia_pd.write().await = None;
        *self.server_duid.write().await = None;
        *self.dns_servers.write().await = Vec::new();
        *self.domain_list.write().await = Vec::new();
        *self.state.write().await = Dhcpv6State::Init;

        Ok(())
    }

    /// Decline addresses
    pub async fn decline(&self, addresses: &[Ipv6Addr]) -> Result<()> {
        info!("Declining DHCPv6 addresses on {}", self.interface);

        if let Some(ref server_duid) = *self.server_duid.read().await {
            let xid: [u8; 3] = rand::random();
            let decline = self.build_decline_message(&xid, server_duid, addresses);

            if let Ok(socket) = self.create_socket() {
                let dest = SocketAddrV6::new(
                    ALL_DHCP_RELAY_AGENTS_AND_SERVERS,
                    DHCPV6_SERVER_PORT,
                    0,
                    self.get_interface_index().unwrap_or(0),
                );

                let _ = socket.send_to(&decline, dest);
                info!("DHCPv6 DECLINE sent on {}", self.interface);
            }
        }

        // Return to INIT state
        *self.state.write().await = Dhcpv6State::Init;

        Ok(())
    }

    /// Shutdown the client
    pub async fn shutdown(&self) {
        *self.shutdown.lock().await = true;
    }

    /// Perform STARTTLS upgrade on a TCP connection (RFC 7653)
    /// This establishes a TLS-secured DHCPv6 connection
    pub async fn starttls(&self, server_addr: std::net::SocketAddrV6) -> Result<Dhcpv6TcpConnection> {
        let mut tls_ctx = self.tls_context.lock().await;

        if !tls_ctx.is_enabled() {
            return Err(DhcpClientError::InvalidConfig(
                "TLS is not enabled in configuration".to_string()
            ));
        }

        // Initialize TLS configuration if not already done
        tls_ctx.init_tls_config()?;

        info!("Initiating DHCPv6 STARTTLS to {}", server_addr);

        // Connect via TCP
        let mut conn = Dhcpv6TcpConnection::connect(server_addr).await?;

        // Generate transaction ID for STARTTLS
        let xid: [u8; 3] = rand::random();

        // Send STARTTLS message
        let starttls_msg = Dhcpv6TlsContext::build_starttls_message(&xid);
        conn.send(&starttls_msg).await?;

        dhcpv6_debug!("Sent STARTTLS message with XID {:02x}{:02x}{:02x}", xid[0], xid[1], xid[2]);

        // Wait for STARTTLS response
        let timeout = Duration::from_secs(self.config.timeout);
        let response = conn.recv(timeout).await?;

        // Verify STARTTLS response
        if !Dhcpv6TlsContext::parse_starttls_response(&response, &xid) {
            conn.close().await;
            return Err(DhcpClientError::ServerError(
                "Server rejected STARTTLS or invalid response".to_string()
            ));
        }

        dhcpv6_debug!("Server accepted STARTTLS, upgrading to TLS");

        // Get server name for TLS
        let server_name = tls_ctx.config.server_name
            .clone()
            .unwrap_or_else(|| server_addr.ip().to_string());

        // Get TLS config
        let tls_config = tls_ctx.get_tls_config()
            .ok_or_else(|| DhcpClientError::InvalidConfig(
                "TLS configuration not initialized".to_string()
            ))?;

        // Perform TLS handshake
        conn.starttls(tls_config, &server_name).await?;

        tls_ctx.set_tls_established(true);
        info!("DHCPv6 STARTTLS completed successfully");

        Ok(conn)
    }

    /// Check if TLS is enabled
    pub async fn is_tls_enabled(&self) -> bool {
        self.tls_context.lock().await.is_enabled()
    }

    /// Check if TLS has been established
    pub async fn is_tls_established(&self) -> bool {
        self.tls_context.lock().await.is_tls_established()
    }
}

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

    #[test]
    fn test_dhcpv6_state_display() {
        assert_eq!(Dhcpv6State::Init.to_string(), "INIT");
        assert_eq!(Dhcpv6State::Solicit.to_string(), "SOLICIT");
        assert_eq!(Dhcpv6State::Bound.to_string(), "BOUND");
    }

    #[test]
    fn test_generate_duid() {
        let mac = [0x00, 0x11, 0x22, 0x33, 0x44, 0x55];
        let duid = Dhcpv6Client::generate_duid(&mac);

        // DUID-LLT: type(2) + hwtype(2) + time(4) + mac(6) = 14 bytes
        assert_eq!(duid.len(), 14);

        // Check type = 1 (DUID-LLT)
        assert_eq!(u16::from_be_bytes([duid[0], duid[1]]), 1);

        // Check hardware type = 1 (Ethernet)
        assert_eq!(u16::from_be_bytes([duid[2], duid[3]]), 1);

        // Check MAC at the end
        assert_eq!(&duid[8..14], &mac);
    }

    #[test]
    fn test_generate_iaid() {
        let iaid1 = Dhcpv6Client::generate_iaid("eth0");
        let iaid2 = Dhcpv6Client::generate_iaid("eth1");

        // Different interfaces should produce different IAIDs
        assert_ne!(iaid1, iaid2);

        // Same interface should produce same IAID
        let iaid1_again = Dhcpv6Client::generate_iaid("eth0");
        assert_eq!(iaid1, iaid1_again);
    }

    #[test]
    fn test_auth_context_creation() {
        use config::Dhcpv6AuthConfig;

        // Test default (disabled) config
        let config = Dhcpv6AuthConfig::default();
        let auth_ctx = Dhcpv6AuthContext::from_config(&config);
        assert!(!auth_ctx.enabled);
        assert!(auth_ctx.key.is_none());

        // Test enabled config with hex key
        let config = Dhcpv6AuthConfig {
            enabled: true,
            protocol: "delayed".to_string(),
            algorithm: "hmac-sha256".to_string(),
            key: Some("0102030405060708090a0b0c0d0e0f10".to_string()),
            key_id: Some(1),
            realm: Some("example.com".to_string()),
            require_server_auth: false,
            accept_unauthenticated: true,
        };
        let auth_ctx = Dhcpv6AuthContext::from_config(&config);
        assert!(auth_ctx.enabled);
        assert!(auth_ctx.key.is_some());
        assert_eq!(auth_ctx.key.as_ref().unwrap().len(), 16);
        assert_eq!(auth_ctx.protocol, AUTH_PROTOCOL_DELAYED);
        assert_eq!(auth_ctx.algorithm, AUTH_ALGORITHM_HMAC_SHA256);
    }

    #[test]
    fn test_auth_context_hmac() {
        use config::Dhcpv6AuthConfig;

        let config = Dhcpv6AuthConfig {
            enabled: true,
            protocol: "delayed".to_string(),
            algorithm: "hmac-sha256".to_string(),
            key: Some("secret_key_for_testing_12345678".to_string()),
            key_id: Some(1),
            realm: None,
            require_server_auth: false,
            accept_unauthenticated: true,
        };
        let auth_ctx = Dhcpv6AuthContext::from_config(&config);

        // Test HMAC computation
        let test_message = b"Test DHCPv6 message data";
        let hmac = auth_ctx.compute_hmac(test_message);
        assert!(hmac.is_some());
        let hmac = hmac.unwrap();
        assert_eq!(hmac.len(), 32); // SHA256 produces 32 bytes

        // Same message should produce same HMAC
        let hmac2 = auth_ctx.compute_hmac(test_message).unwrap();
        assert_eq!(hmac, hmac2);

        // Different message should produce different HMAC
        let hmac3 = auth_ctx.compute_hmac(b"Different message").unwrap();
        assert_ne!(hmac, hmac3);
    }

    #[test]
    fn test_auth_option_building() {
        use config::Dhcpv6AuthConfig;

        let config = Dhcpv6AuthConfig {
            enabled: true,
            protocol: "delayed".to_string(),
            algorithm: "hmac-sha256".to_string(),
            key: Some("test_key_123456789012345678901234".to_string()),
            key_id: Some(42),
            realm: Some("test.local".to_string()),
            require_server_auth: false,
            accept_unauthenticated: true,
        };
        let mut auth_ctx = Dhcpv6AuthContext::from_config(&config);

        // Build a test message (SOLICIT-like)
        let test_msg = vec![
            DHCPV6_SOLICIT, 0x01, 0x02, 0x03,  // Message type + XID
            0x00, 0x01, 0x00, 0x04, 0xde, 0xad, 0xbe, 0xef,  // Client ID option (fake)
        ];

        let auth_option = auth_ctx.build_auth_option(&test_msg);
        assert!(auth_option.is_some());

        let auth_data = auth_option.unwrap();
        // Check protocol
        assert_eq!(auth_data[0], AUTH_PROTOCOL_DELAYED);
        // Check algorithm
        assert_eq!(auth_data[1], AUTH_ALGORITHM_HMAC_SHA256);
        // Check RDM
        assert_eq!(auth_data[2], RDM_MONOTONIC_COUNTER);
        // Replay detection (8 bytes) starts at offset 3
        // Realm starts at offset 11, followed by null terminator
        // Key ID (4 bytes) follows
        // HMAC (32 bytes for SHA256) at the end
    }

    #[test]
    fn test_tls_context_creation() {
        use config::Dhcpv6TlsConfig;

        // Test default (disabled) config
        let config = Dhcpv6TlsConfig::default();
        let tls_ctx = Dhcpv6TlsContext::from_config(&config);
        assert!(!tls_ctx.is_enabled());
        assert!(!tls_ctx.use_tcp());
        assert!(!tls_ctx.is_tls_established());

        // Test enabled config
        let config = Dhcpv6TlsConfig {
            enabled: true,
            use_tcp: true,
            require_tls: true,
            verify_server: true,
            server_name: Some("dhcp.example.com".to_string()),
            ca_cert: None,
            client_cert: None,
            client_key: None,
            min_version: "1.3".to_string(),
            tcp_port: 547,
        };
        let tls_ctx = Dhcpv6TlsContext::from_config(&config);
        assert!(tls_ctx.is_enabled());
        assert!(tls_ctx.use_tcp());
    }

    #[test]
    fn test_starttls_message_building() {
        let xid = [0x12, 0x34, 0x56];

        let msg = Dhcpv6TlsContext::build_starttls_message(&xid);

        // STARTTLS message: type (1 byte) + XID (3 bytes) = 4 bytes
        assert_eq!(msg.len(), 4);

        // Check message type is STARTTLS (23)
        assert_eq!(msg[0], DHCPV6_STARTTLS);

        // Check XID
        assert_eq!(&msg[1..4], &xid);
    }

    #[test]
    fn test_starttls_response_parsing() {
        let xid = [0xAB, 0xCD, 0xEF];

        // Valid STARTTLS response
        let valid_response = vec![DHCPV6_STARTTLS, 0xAB, 0xCD, 0xEF];
        assert!(Dhcpv6TlsContext::parse_starttls_response(&valid_response, &xid));

        // Wrong message type
        let wrong_type = vec![DHCPV6_SOLICIT, 0xAB, 0xCD, 0xEF];
        assert!(!Dhcpv6TlsContext::parse_starttls_response(&wrong_type, &xid));

        // Wrong XID
        let wrong_xid = vec![DHCPV6_STARTTLS, 0x00, 0x00, 0x00];
        assert!(!Dhcpv6TlsContext::parse_starttls_response(&wrong_xid, &xid));

        // Too short
        let too_short = vec![DHCPV6_STARTTLS, 0xAB, 0xCD];
        assert!(!Dhcpv6TlsContext::parse_starttls_response(&too_short, &xid));

        // Empty
        let empty: Vec<u8> = vec![];
        assert!(!Dhcpv6TlsContext::parse_starttls_response(&empty, &xid));
    }
}