#![deny(missing_docs)]

//! The data structures for representing a XIO hardware database.

#[macro_use]
extern crate serde_derive;

#[macro_use]
extern crate serde_hex;

#[cfg(test)]
#[macro_use]
extern crate serde_json;

#[cfg(not(test))]
extern crate serde_json;

extern crate indexmap;
extern crate ommui_file_loading;
extern crate ommui_string_patterns;
extern crate serde;
extern crate uuid;
extern crate xio_base_datatypes;

use ommui_string_patterns::{freetextstring, idstring};
use std::collections::BTreeMap;
use uuid::Uuid;
use xio_base_datatypes as base;

mod hexnumber;

/// Functionality for loading a XIO hardware database from files.
pub mod filesystem;

/// The description of a device.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct DeviceDescription {
    /// Description of the FTDI flashing chip.
    pub ftdi: FtdiDescription,

    /// Description of the XIO properties.
    pub xio: Option<XioDescription>,

    /// Description of the system.
    pub system: SystemDescription,

    /// Summary of the device status.
    pub summary: SummaryDescription,
}

/// The description of a connected device recognized by FTDI chip.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct FtdiDescription {
    /// The string identifier stored in the FTDI EEPROM.
    pub id: String,

    /// The vendor string stored in the FTDI EEPROM.
    pub vendor: String,

    /// The product string stored in the FTDI EEPROM.
    pub product: String,

    /// The uuid stored in the FTDI EEPROM.
    pub uuid: Uuid,

    /// A flag indicating if the device is recognized.
    pub recognized: bool,

    /// A flag indicating if the device is programmed (a.k.a. flashed).
    pub programmed: bool,

    /// Board identifier string.
    pub board: String,

    /// Device path.
    pub device: String,

    /// Named symlink to the device.
    pub symlink: String,
}

/// The description of a connected device recognized through USB.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct XioDescription {
    /// Id of the device.
    pub id: String,

    /// USB vendor string of the device.
    pub vendor: String,

    /// USB product string of the device.
    pub product: String,

    /// Device uuid.
    pub uuid: Uuid,

    /// Flag indicating if the device is recognized.
    pub recognized: bool,

    /// Flag indicating if the device is programmed (a.k.a. flashed).
    pub programmed: bool,

    /// Board identifier string.
    pub board: String,

    /// Device path.
    pub device: String,

    /// Named symlink to the device.
    pub symlink: String,

    /// Version string of the firmware running on the device.
    pub version: String,
}

/// Systems description of a XIO device.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SystemDescription {
    /// Version of the device.
    pub version: String,

    /// Version string of the firmware running on the device.
    pub firmware: String,
}

/// Summary information of a XIO device.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct SummaryDescription {
    /// Flag indicating if the device is ready.
    pub ready: bool,
}

/// Description of a XIO device hardware board type.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct HardwareBoardDescription {
    /// Name of the board.
    #[serde(rename = "_caption", with = "freetextstring")]
    pub caption: String,

    /// Generic description of the board.
    pub description: GenericDescription,

    /// Capabilities provided by the board.
    pub capabilities: BTreeMap<String, Capability>,
}

/// Generic description of some device properties.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct GenericDescription {
    /// Vendor of the device.
    #[serde(with = "freetextstring")]
    pub vendor: String,

    /// Model name of the device.
    #[serde(with = "freetextstring")]
    pub model: String,
}

/// A capability implemented in a XIO device.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Capability {
    /// Flag indicating if the capability is built into the device.
    pub builtin: bool,

    /// String identifier of the module type.
    ///
    /// The module must be present in the modules collection that
    /// can be loaded through the `filesystem::HardwareDatabase`.
    #[serde(with = "idstring")]
    pub module: String,

    /// The index number of the capability within the XIO device.
    #[serde(with = "hexnumber")]
    pub id: u16,
}

#[cfg(test)]
mod capability_tests {
    extern crate serde_json;
    use super::Capability;

    #[test]
    fn deserialize_hex() {
        let json =
            json!({ "builtin": true, "module": "xyz", "id": "0x1234"});
        let cap: Capability =
            serde_json::from_str(&json.to_string()).unwrap();
        assert_eq!(
            cap,
            Capability {
                builtin: true,
                module: "xyz".to_string(),
                id: 0x1234,
            }
        );
        assert_eq!(serde_json::to_value(cap).unwrap(), json);
    }

    #[test]
    fn deserialize_hex_zero() {
        let json =
            json!({ "builtin": true, "module": "xyz", "id": "0x0000"});
        let cap: Capability =
            serde_json::from_str(&json.to_string()).unwrap();
        assert_eq!(
            cap,
            Capability {
                builtin: true,
                module: "xyz".to_string(),
                id: 0,
            }
        );
        assert_eq!(serde_json::to_value(cap).unwrap(), json);
    }

    #[test]
    fn deserialize() {
        let json = json!({ "builtin": true, "module": "xyz", "id": 1234});
        let cap: Capability =
            serde_json::from_str(&json.to_string()).unwrap();
        assert_eq!(
            cap,
            Capability {
                builtin: true,
                module: "xyz".to_string(),
                id: 1234,
            }
        );
        let json_hex =
            json!({ "builtin": true, "module": "xyz", "id": "0x04d2"});
        assert_eq!(serde_json::to_value(cap).unwrap(), json_hex);
    }
}

/// Description of a XIO module.
///
/// This describes the functionality that can be provided by a
/// module. A XIO board can have multiple capabilities referencing
/// the same module description. If a board has e.g. two A/D converters
/// of the same type, there are two capabilities which reference the
/// same module id.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Module {
    /// Caption of the module.
    #[serde(rename = "_caption", with = "freetextstring")]
    pub caption: String,

    /// Generic description of the module.
    pub description: GenericDescription,

    /// List of channels provided by the module.
    pub channels: Vec<Channel>,
}

/// Description of a channel available in a XIO module.
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Channel {
    /// String identifier of the module.
    ///
    /// Must be unique among all channels that are contained in a module.
    #[serde(with = "idstring")]
    pub id: String,

    /// Caption of the channel.
    #[serde(rename = "_caption", with = "freetextstring")]
    pub caption: String,

    /// Dataype of the channel value.
    #[serde(rename = "type")]
    pub channel_type: base::DataType,

    /// Access permissions of the channel.
    pub permission: base::ChannelPermission,
}