use ring::digest::{Context, SHA256};

use serde::Deserialize;
use std::collections::BTreeMap; //BTreeMap instead of hashmap to maintain ordering of arguments

use crate::result::{diagnostic::Location, CompilerResult};

/// Represents a drivers TOML file.
#[derive(Debug, PartialEq, Deserialize)]
pub struct DriversFile {
    /// Drivers in the file
    pub drivers: Drivers,
    /// Hash digest
    pub hash: Vec<u8>, // TODO include file name
}
/// Represents the drivers data within a drivers TOML file.
#[derive(Debug, PartialEq, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Drivers {
    /// Drivers Version
    pub version: String,
    /// Vector of drivers for virtual sensors
    pub sensor: Vec<VirtualSensorDriver>,

    /// Vector of drivers for virtual relays
    pub relay: Vec<VirtualRelayDriver>,
}
/// Represents the metadata for a virtual sensor.
#[derive(Debug, PartialEq, Deserialize)]
pub struct VirtualSensorDriver {
    /// The namespace of the driver.
    pub namespace: String,
    /// The function of the driver
    pub function: String,
    /// Input fields for the driver
    // TODO what order do the fields need to be in
    pub fields: Option<Vec<BTreeMap<String, String>>>,
}

/// Represents the metadata for a virtual relay.
#[derive(Debug, PartialEq, Deserialize)]
pub struct VirtualRelayDriver {
    /// The namespace of the driver.
    pub namespace: String,
    /// The function of the driver
    pub function: String,
    /// Input fields for the driver
    // TODO what order do the fields need to be in
    pub fields: Option<Vec<BTreeMap<String, String>>>,
}

impl Drivers {
    /// Parse the provided file_name as a Drivers.toml file.
    /// Outputs a DriversFile struct wrapped in a CompilerResult.
    pub fn parse(file_id: usize, file_name: String, contents: &str) -> CompilerResult<DriversFile> {
        let mut res = CompilerResult::new("Parsing a drivers file");

        let taplo_parse = taplo::parser::parse(contents);

        let taplo_dom = taplo_parse.clone().into_dom();

        //Check for TOML syntax errors
        if !taplo_parse.errors.is_empty() {
            for error in taplo_parse.errors {
                let location = Location::from_raw(
                    file_id,
                    error.range.start().into(),
                    error.range.end().into(),
                );
                res.error((location, error.to_string()));
            }
        }

        //Check for TOML semantic errors
        if !taplo_dom.errors().is_empty() {
            for error in taplo_dom.errors() {
                res.error(format!("{}\n\t{}", error.to_string(), file_name));
            }
        }

        // Compute hash of the drivers file
        let drivers: Drivers = check!(res, toml::from_str(contents));
        let mut context = Context::new(&SHA256);
        context.update(contents.as_bytes());
        // Get the hash digest and convert it to a vector
        let hash = context.finish().as_ref().to_vec();

        let drivers_file = DriversFile {
            drivers,
            hash: hash,
        };
        res.with_value(drivers_file)
    }
    /// Return the index into the drivers table for the given sensor driver name
    pub fn get_sensor_driver_index(&self, driver_name: &str) -> Option<u16> {
        for (idx, sensor_driver) in self.sensor.iter().enumerate() {
            let sensor_driver_name =
                sensor_driver.namespace.clone() + "/" + sensor_driver.function.clone().as_str();
            if driver_name.eq(sensor_driver_name.as_str()) {
                return Some(idx as u16);
            }
        }
        None
    }
    /// Return a reference to the sensor driver with the given sensor driver name
    pub fn get_sensor_driver(&self, driver_name: &str) -> Option<&VirtualSensorDriver> {
        let driver_idx = self.get_sensor_driver_index(driver_name);
        if let Some(driver_idx) = driver_idx {
            return Some(&self.sensor[driver_idx as usize]);
        }
        None
    }
    /// Return the index into the drivers table for the given relay driver name
    pub fn get_relay_driver_index(&self, driver_name: &str) -> Option<u16> {
        for (idx, relay_driver) in self.relay.iter().enumerate() {
            let relay_driver_name =
                relay_driver.namespace.clone() + "/" + relay_driver.function.clone().as_str();
            if driver_name.eq(relay_driver_name.as_str()) {
                return Some(idx as u16);
            }
        }
        None
    }
    /// Return a reference to the relay driver with the given relay driver name
    pub fn get_relay_driver(&self, driver_name: &str) -> Option<&VirtualRelayDriver> {
        let driver_idx = self.get_relay_driver_index(driver_name);
        if let Some(driver_idx) = driver_idx {
            return Some(&self.relay[driver_idx as usize]);
        }
        None
    }
}

impl VirtualRelayDriver {
    /// Return the index for the given argument name
    pub fn get_arg_index(&self, arg_name: &str) -> Option<u16> {
        if let Some(args) = &self.fields {
            for (idx, arg) in args.iter().enumerate() {
                // This line seems really messy
                if arg.get("name") == Some(&arg_name.to_string()) {
                    return Some(idx as u16);
                }
            }
        }
        None
    }
}

impl VirtualSensorDriver {
    /// Return the index for the given argument name
    pub fn get_arg_index(&self, arg_name: &str) -> Option<u16> {
        if let Some(args) = &self.fields {
            for (idx, arg) in args.iter().enumerate() {
                // This line seems really messy
                if arg.get("name") == Some(&arg_name.to_string()) {
                    return Some(idx as u16);
                }
            }
        }
        None
    }
}

#[cfg(test)]
mod tests {
    use codespan_reporting::files::SimpleFiles;

    use super::*;

    #[test]
    fn toml_test() {
        let input = r#"version = "0.1"

[[relay]]
namespace = "MissionControl"
function = "UDP_Command"
fields = [{ name = "id", type = "u16" }]

[[sensor]]
namespace = "MissionControl"
function = "UDP_Request"
fields = [{ name = "stand_id", type = "u16" }]

[[sensor]]
namespace = "TestStand"
function = "RedundantAggregate"
fields = [
    { name = "device_address_a", type = "u16" },
    { name = "device_address_b", type = "u16" },
    { name = "lower", type = "u16" },
    { name = "upper", type = "u16" },
]
"#;
        // Calculated from python hashing script
        let expected_hash = [
            31, 189, 160, 233, 117, 157, 172, 154, 176, 22, 91, 206, 212, 23, 191, 133, 92, 170,
            250, 217, 194, 189, 23, 33, 93, 196, 146, 95, 97, 5, 246, 194,
        ]
        .to_vec();

        // Compute hash of the drivers file
        let mut context = Context::new(&SHA256);
        context.update(input.as_bytes());
        // Get the hash digest and convert it to a vector
        let test_hash = context.finish().as_ref().to_vec();

        assert_eq!(expected_hash, test_hash);

        // Construct hashmap for every argument to each driver
        // and construct a vector with each argument's hashmap
        let mut sensor_id = BTreeMap::new();
        sensor_id.insert("name".into(), "stand_id".into());
        sensor_id.insert("type".into(), "u16".into());
        //Create vector of hashmaps for the first sensor driver
        let sensor_args_1: Vec<BTreeMap<String, String>> = vec![sensor_id];

        let mut sensor_device_address_a = BTreeMap::new();
        sensor_device_address_a.insert("name".into(), "device_address_a".into());
        sensor_device_address_a.insert("type".into(), "u16".into());
        let mut sensor_device_address_b = BTreeMap::new();
        sensor_device_address_b.insert("name".into(), "device_address_b".into());
        sensor_device_address_b.insert("type".into(), "u16".into());
        let mut sensor_lower = BTreeMap::new();
        sensor_lower.insert("name".into(), "lower".into());
        sensor_lower.insert("type".into(), "u16".into());
        let mut sensor_higher = BTreeMap::new();
        sensor_higher.insert("name".into(), "upper".into());
        sensor_higher.insert("type".into(), "u16".into());
        //Create vector of hashmaps for the second sensor driver
        let sensor_args_2: Vec<BTreeMap<String, String>> = vec![
            sensor_device_address_a,
            sensor_device_address_b,
            sensor_lower,
            sensor_higher,
        ];

        let mut relay_id = BTreeMap::new();
        relay_id.insert("name".into(), "id".into());
        relay_id.insert("type".into(), "u16".into());
        //Create vector of hashmaps for the first relay driver
        let relay_args_1: Vec<BTreeMap<String, String>> = vec![relay_id];

        let sensor_drivers: Vec<VirtualSensorDriver> = vec![
            VirtualSensorDriver {
                namespace: "MissionControl".into(),
                function: "UDP_Request".into(),
                fields: Some(sensor_args_1),
            },
            VirtualSensorDriver {
                namespace: "TestStand".into(),
                function: "RedundantAggregate".into(),
                fields: Some(sensor_args_2),
            },
        ];
        let relay_drivers: Vec<VirtualRelayDriver> = vec![VirtualRelayDriver {
            namespace: "MissionControl".into(),
            function: "UDP_Command".into(),
            fields: Some(relay_args_1),
        }];
        let files = SimpleFiles::new();
        Drivers::parse(0, "empty".to_string(), input)
            .print(&files)
            .expect("Failed to parse drivers file");
        let actual: DriversFile = Drivers::parse(0, "empty".to_string(), input)
            .to_option()
            .unwrap();

        assert_eq!(sensor_drivers, actual.drivers.sensor);
        assert_eq!(relay_drivers, actual.drivers.relay);
        assert_eq!(expected_hash, actual.hash);
    }
}