use crc_any::CRCu32;

use crate::environment::calibration::Calibration;
use crate::environment::config;
use crate::result::CompilerResult;
use crate::version;
use crate::{bits::BitWriter, environment::Environment};
use config::VirtualRelayRecord;
use config::VirtualSensorRecord;

impl Environment {
    /// Length of the binary config header in bytes
    const HEADER_LEN: u32 = 76;
    /// Length of the binary config section headers in bytes
    const SECTION_HEADER: u32 = 4;
    /// Length of a single relay in bytes
    const RELAY_LEN: u32 = 2;
    /// Length of a single sensor in bytes
    const SENSOR_LEN: u32 = 3;
    /// Length of a single global bounds entry in bytes
    const GLOBAL_BOUNDS_LEN: u32 = 4;

    /// Appends the binary config header to a buffer
    fn append_header_to_buffer(&self, buffer: &mut BitWriter) {
        // compute offsets for all sections
        let mut offset = Environment::HEADER_LEN;
        let relay_offset = offset;

        offset +=
            Environment::SECTION_HEADER + self.config.relays.len() as u32 * Environment::RELAY_LEN;
        let sensors_offset = offset;

        offset += Environment::SECTION_HEADER
            + self.config.sensors.len() as u32 * Environment::SENSOR_LEN;
        let virtual_relays_offset = offset;

        offset += Environment::SECTION_HEADER;
        for v_relay in self.config.virtuals.relays.values() {
            offset += v_relay.len()
        }
        let virtual_sensors_offset = offset;

        offset += Environment::SECTION_HEADER;
        for v_sensor in self.config.virtuals.sensors.values() {
            offset += v_sensor.len()
        }
        let safe_state_offset = offset;

        offset += Environment::SECTION_HEADER
            + Environment::RELAY_LEN * self.config.safe_state.len() as u32;

        let global_bounds_offset = offset;

        let mut num_global_bounds = 0;
        if let Some(global_bounds_ref) = self.config.global_bounds.as_ref() {
            num_global_bounds = global_bounds_ref.len();
        }
        offset +=
            Environment::SECTION_HEADER + Environment::GLOBAL_BOUNDS_LEN * num_global_bounds as u32;
        let footer_offset = offset;

        // Create the Header>

        // Prefix (0:3)
        buffer.append(b'.');
        buffer.append(b'C');
        buffer.append(b'B');
        buffer.append(b'F');

        // Timestamp (4:11)
        buffer.append(now());

        // Versioning (major, minor, patch) (12:15)
        buffer.append(version::MAJOR);
        buffer.append(version::MINOR);
        buffer.append(version::PATCH);
        buffer.append(0u8); //padding

        // Drivers hash
        // If drivers exist append hash to buffer
        if let Some(drivers_file) = &self.drivers_file {
            for byte in &drivers_file.hash {
                buffer.append(*byte);
            }
        }
        // Else append 32 bytes of zero
        else {
            buffer.append(0u128);
            buffer.append(0u128);
        }

        // Relays offset (20:23)
        buffer.append(relay_offset);

        // Sensors offset (24:27)
        buffer.append(sensors_offset);

        // Virtual relays offset (28:31)
        buffer.append(virtual_relays_offset);

        // Virtual sensors offset (32:35)
        buffer.append(virtual_sensors_offset);

        // Safe state offset (36:39)
        buffer.append(safe_state_offset);

        // Global bounds offset (40:43)
        buffer.append(global_bounds_offset);

        // Footer offset (44:47)
        buffer.append(footer_offset);
    }

    /// Appends the relays to a buffer
    fn append_relays_to_buffer(&self, buffer: &mut BitWriter) {
        // Header Prefix
        buffer.append(0xF0u8);
        // Section Length
        buffer.append_tail(
            Environment::SECTION_HEADER + self.config.relays.len() as u32 * Environment::RELAY_LEN,
            24,
        );
        // Relays
        for relay_record in self.config.get_relay_records() {
            // Append '001000'b
            buffer.append_tail(0b001000 as u16, 6);
            // Append 10-bit virtual address
            buffer.append_tail(u16::from(relay_record.device_address), 10)
        }
    }

    /// Appends the sensors to a buffer
    fn append_sensors_to_buffer(&self, buffer: &mut BitWriter) {
        // Header Prefix
        buffer.append(0xF1u8);
        // Section Length
        buffer.append_tail(
            Environment::SECTION_HEADER
                + self.config.sensors.len() as u32 * Environment::SENSOR_LEN,
            24,
        );
        // Sensors
        for sensor_record in self.config.get_sensor_records() {
            // Append '010000'b
            buffer.append_tail(0b010000 as u16, 6);
            // Append 10-bit virtual device_address
            buffer.append_tail(u16::from(sensor_record.device_address), 10);
            buffer.append_tail(sensor_record.polling_interval_ms, 8);
        }
    }

    /// Appends the virtual relays to a buffer
    fn append_v_relays_to_buffer(&self, buffer: &mut BitWriter) {
        // Header Prefix
        buffer.append(0xF2u8);
        // Section Length
        let mut length = Environment::SECTION_HEADER;
        for v_relay in self.config.virtuals.relays.values() {
            length += v_relay.len();
        }
        buffer.append_tail(length, 24);

        // Virtual Relays
        for v_relay in &self.config.get_v_relay_records() {
            let v_relay_record = v_relay;
            // This unwrap shouldn't ever fail
            let drivers = &self.drivers_file.as_ref().unwrap().drivers;
            // Add drivers table index
            let driver_index = drivers.get_relay_driver_index(v_relay_record.driver.as_str());
            buffer.append_tail(driver_index.unwrap(), 6);
            // Add device_address
            buffer.append_tail(u16::from(v_relay_record.device_address), 10);
            // Add args
            if let Some(args) = v_relay_record.args.as_ref() {
                // get the specific driver struct from the name of the driver
                let driver_opt = drivers.get_relay_driver(v_relay_record.driver.as_str());
                // This unwrap should never fail due to earlier error checking
                let driver = driver_opt.unwrap();

                let mut args_vec: Vec<(&String, &u16)> = args.into_iter().collect();
                let num_args = args_vec.len() as u16;
                // Sort the arguments provided in the config.toml by their indices
                // in the arguments vector for this driver.
                args_vec.sort_by(|a, b| driver.get_arg_index(a.0).cmp(&driver.get_arg_index(b.0)));

                // Append the number of arguments to the buffer
                buffer.append_tail(num_args, 8);

                // Append every argument to the buffer
                for arg in args_vec {
                    buffer.append_tail(*arg.1, 16);
                }
            }
        }
    }

    /// Appends the virtual sensors to a buffer
    fn append_v_sensors_to_buffer(&self, buffer: &mut BitWriter) {
        // Header Prefix
        buffer.append(0xF3u8);
        // Section Length
        let mut length = Environment::SECTION_HEADER;
        for v_sensor in self.config.virtuals.sensors.values() {
            length += v_sensor.len();
        }
        buffer.append_tail(length, 24);
        // Virtual Sensors
        for v_sensor_record in &self.config.get_v_sensor_records() {
            // This unwrap shouldn't ever fail
            let drivers = &self.drivers_file.as_ref().unwrap().drivers;
            // Add drivers table index
            let driver_index = drivers.get_sensor_driver_index(v_sensor_record.driver.as_str());
            buffer.append_tail(driver_index.unwrap(), 6);
            // Add device_address
            buffer.append_tail(u16::from(v_sensor_record.device_address), 10);
            buffer.append_tail(v_sensor_record.polling_interval_ms, 8);
            // Add args
            if let Some(args) = v_sensor_record.args.as_ref() {
                // get the specific driver struct from the name of the driver
                let driver_opt = drivers.get_sensor_driver(&v_sensor_record.driver);
                // This unwrap should never fail due to earlier error checking
                let driver = driver_opt.unwrap();

                let mut args_vec: Vec<(&String, &u16)> = args.into_iter().collect();
                let num_args = args_vec.len() as u16;

                // Sort the arguments provided in the config.toml by their indices
                // in the arguments vector for this driver.
                args_vec.sort_by(|a, b| driver.get_arg_index(a.0).cmp(&driver.get_arg_index(b.0)));

                // Append the number of arguments to the buffer
                buffer.append_tail(num_args, 8);

                // Append every argument to the buffer
                for arg in args_vec {
                    buffer.append_tail(*arg.1, 16);
                }
            }
        }
    }

    /// Appends the safe state to a buffer
    fn append_safe_state_to_buffer(&self, buffer: &mut BitWriter) {
        // Header Prefix
        buffer.append(0xF4u8);
        // Section Length
        buffer.append_tail(
            Environment::SECTION_HEADER
                + self.config.safe_state.len() as u32 * Environment::RELAY_LEN,
            24,
        );
        // Physical Relays
        for relay_record in self.config.get_safe_state_relay_records() {
            // Append 1-bit '0'b physical address flag
            buffer.append_tail(0b0 as u16, 1);
            // Append 10-bit device address
            buffer.append_tail(u16::from(relay_record.device_address), 10);
            // Append '00000'b padding
            buffer.append_tail(0b00000 as u16, 5);
        }
        // Virtual Relays
        for relay_record in self.config.get_safe_state_v_relay_records() {
            // Append 1-bit '1'b physical address flag
            buffer.append_tail(0b1 as u16, 1);
            // Append 10-bit device address
            buffer.append_tail(u16::from(relay_record.device_address), 10);
            // Append '00000'b padding
            buffer.append_tail(0b00000 as u16, 5);
        }
    }

    /// Appends the global bounds to a buffer
    fn append_global_bounds_to_buffer(&self, buffer: &mut BitWriter) -> CompilerResult<()> {
        let mut res = CompilerResult::status_only("Append global bounds to CBF buffer");
        // Header Prefix
        buffer.append(0xF6u8);
        if let Some(global_bounds) = self.config.global_bounds.clone() {
            let num_bounds = global_bounds.keys().len() as u32;
            // append header length
            buffer.append_tail(Environment::SECTION_HEADER + num_bounds * 4, 24);

            for (sensor_id, bound) in global_bounds.into_iter() {
                let device_addr = self
                    .config
                    .get_sensor_device_address(&sensor_id)
                    .to_option();

                // Get the calibration file for this sensor if it exists
                let calibration_opt = check!(res, self.get_calibration(&sensor_id));

                // Convert the floating point bounds using a calibration lookup
                let bounds_res = match calibration_opt {
                    Some(calibration) => match calibration {
                        Calibration::Numeric(numeric_calibration) => {
                            Environment::numeric_calibration_lookup(
                                numeric_calibration,
                                (bound.left, bound.right),
                            )
                        }
                        Calibration::Boolean(_) => unimplemented!(
                            "Global bounds for a boolean sensore are not implemented!"
                        ),
                    },
                    None => Environment::raw_calibration_lookup((bound.left, bound.right)),
                };
                let bounds = check!(res, bounds_res);

                match device_addr {
                    Some(addr) => {
                        buffer.append_tail(addr.virtuality, 1);
                        buffer.append_tail(addr.value, 10);
                        buffer.append_tail(bounds.0,12);
                        buffer.append_tail(bounds.1,12);
                        // append padding
                        buffer.append_tail(0u16, 5);
                    },
                    None => res.error("Sensor ID not found in config. validate_safe_state function must have failed"),
                }
            }
        // We don't have any entries so just append base section length
        } else {
            buffer.append_tail(Environment::SECTION_HEADER, 24)
        }

        res
    }

    /// Appends the binary config footer to the buffer
    fn append_footer_to_buffer(&self, buffer: &mut BitWriter) -> u32 {
        let buffer_clone = buffer.clone();
        let config_bytes = buffer_clone.as_bytes();

        // Section Prefix
        buffer.append(0xF5u8);

        // Hash
        let mut crc32 = CRCu32::crc32q();
        crc32.digest(config_bytes);
        buffer.append(crc32.get_crc());
        // NL - Newline to assist editors
        buffer.append(b'\n');

        // Return the crc hash
        crc32.get_crc()
    }

    /// Appends the body of the config to a buffer
    pub fn append_to_buffer(&self, buffer: &mut BitWriter) -> u32 {
        // Append header
        self.append_header_to_buffer(buffer);

        // Append relays
        self.append_relays_to_buffer(buffer);

        // Append sensors
        self.append_sensors_to_buffer(buffer);

        // Append virtual relays
        self.append_v_relays_to_buffer(buffer);

        // Append virtual sensors
        self.append_v_sensors_to_buffer(buffer);

        // Append safe state
        self.append_safe_state_to_buffer(buffer);

        // Append global bounds
        self.append_global_bounds_to_buffer(buffer);

        // Append footer
        let crc_hash = self.append_footer_to_buffer(buffer);

        // return the crc hash
        crc_hash
    }
}

impl VirtualRelayRecord {
    /// Computes the number of bytes this virtual
    /// relay will use after serialization
    pub fn len(&self) -> u32 {
        // Driver index, device_address, and num_args take up 3 bytes
        let mut len: u32 = 3;
        // Add two bytes for every argument to the virtual relay driver
        if let Some(args) = self.args.as_ref() {
            len += args.len() as u32 * 2;
        }
        len
    }
}

impl VirtualSensorRecord {
    /// Computes the number of bytes this virtual
    /// relay will use after serialization
    pub fn len(&self) -> u32 {
        // Driver index, device_address, polling_interval, and num_args take up 4 bytes
        let mut len: u32 = 4;
        // Add two bytes for every argument to the virtual sensor driver
        if let Some(args) = self.args.as_ref() {
            len += args.len() as u32 * 2;
        }
        len
    }
}

fn now() -> u64 {
    use std::time::{SystemTime, UNIX_EPOCH};

    let start = SystemTime::now();
    let since_the_epoch = start
        .duration_since(UNIX_EPOCH)
        .expect("Time went backwards");

    since_the_epoch.as_millis() as u64
}