#[macro_use]
extern crate serde_derive;

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

extern crate ommui_string_patterns;
extern crate xio_base_datatypes;

mod extract_captions;

pub use extract_captions::{CommandCaption, ExtractCaptions};
use ommui_string_patterns::freetextstring;
use std::collections::BTreeMap;
use xio_base_datatypes as base;

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
/// A complete job set.
pub struct JobSet {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub parameters: Vec<ParameterSet>,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub jobs: BTreeMap<String, Job>,
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub channels: BTreeMap<String, ChannelAssignment>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ParameterSet {
    pub name: String,
    pub descriptions: BTreeMap<String, ParameterDescription>,
    pub values: BTreeMap<String, base::DataValueDescriptive>,
}

#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ParameterDescription {
    #[serde(rename = "_caption")]
    pub caption: String,
    #[serde(rename = "type")]
    pub data_type: base::DataType,
    pub storage: base::StorageType,
    #[serde(rename = "override")]
    pub override_option: base::OverrideOption,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Job {
    pub commands: Vec<Command>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Command {
    #[serde(rename = "_caption", with = "freetextstring")]
    pub caption: String,

    #[serde(rename = "type")]
    pub command_type: String,

    // TODO: verify that the key is an idstring
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub parameters: BTreeMap<String, String>,

    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub conditions: Vec<Condition>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct Condition {
    #[serde(rename = "_caption", with = "freetextstring")]
    pub caption: String,

    #[serde(rename = "type")]
    pub command_type: String,

    pub exit_job: bool,

    // TODO: verify that the key is an idstring
    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
    pub parameters: BTreeMap<String, String>,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ChannelAssignment {
    pub capability: String,
    pub channel: String,
}

#[derive(Clone, Debug, Default, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
/// The assignment of variables mapped to a hardware board
pub struct HardwareAssignment {
    pub hardware_board: String,
    pub mapping: BTreeMap<String, ChannelAssignment>,
}

#[cfg(test)]
mod tests {
    use base::{DataType, DataValue, DataValueDescriptive, OverrideOption,
               StorageType};
    use std::collections::BTreeSet;
    use {serde_json, BTreeMap, ChannelAssignment, Command, Condition,
         Job, JobSet, ParameterDescription, ParameterSet};

    #[test]
    fn example_jobset() {
        let json = json!({
            "channels":{
                "a1":{
                    "capability":"motor",
                    "channel":"speed"
                },
                "a3":{
                    "capability":"adc",
                    "channel":"voltage"
                }
            },
            "jobs":{
                "init":{
                    "commands":[
                        {
                            "_caption":"init job command 1",
                            "conditions":[
                            {
                                "_caption":"init job cmd 1 condition 1",
                                "exitJob":true,
                                "parameters":{"a":"a1","b":"b1"},
                                "type":"equals"
                            }
                            ],
                            "parameters":{"a":"b1","b":"a1"},
                            "type":"wait"
                        },
                        {
                            "_caption":"init job command 2",
                            "parameters":{"a":"b1"},
                            "type":"wait"
                        }
                    ]
                },
                "measurement":{
                    "commands": [
                        {
                            "_caption":"measurement job command 1",
                            "type":"wait"
                        },
                        {
                            "_caption":"measurement job command 2",
                            "type":"wait"
                        }
                    ]
                }
            },
            "parameters":[
                {
                    "descriptions":{
                        "a1":{
                            "_caption":"Parameter A 1",
                            "override":"forbid",
                            "storage":"channel",
                            "type":"uint8"
                        },
                        "a2":{
                            "_caption":"Parameter A 2",
                            "override":"enforce",
                            "storage":"fixed",
                            "type":"parametermask"
                        },
                        "a3":{
                            "_caption":"Parameter A 3",
                            "override":"allow",
                            "storage":"channel",
                            "type":"boolean"
                        }
                    },
                    "name":"base",
                    "values":{"a1":3,"a2":["a3","b1"]}
                },
                {
                    "descriptions":{
                        "b1":{
                            "_caption":"Parameter B 1",
                            "override":"forbid",
                            "storage":"channel",
                            "type":"uint8"
                        }
                    },
                    "name":"overlay",
                    "values":{"b1":14}
                }
            ]
        });
        let parameterset1 = ParameterSet {
            name: "base".to_string(),
            descriptions: vec![
                (
                    "a1".to_string(),
                    ParameterDescription {
                        caption: "Parameter A 1".to_string(),
                        data_type: DataType::UInt8,
                        storage: StorageType::Channel,
                        override_option: OverrideOption::Forbid,
                    },
                ),
                (
                    "a2".to_string(),
                    ParameterDescription {
                        caption: "Parameter A 2".to_string(),
                        data_type: DataType::ParameterMask,
                        storage: StorageType::Fixed,
                        override_option: OverrideOption::Enforce,
                    },
                ),
                (
                    "a3".to_string(),
                    ParameterDescription {
                        caption: "Parameter A 3".to_string(),
                        data_type: DataType::Boolean,
                        storage: StorageType::Channel,
                        override_option: OverrideOption::Allow,
                    },
                ),
            ].into_iter()
                .collect::<BTreeMap<String, ParameterDescription>>(),
            values: vec![
                ("a1".to_string(), DataValue::UInt8(3u8)),
                (
                    "a2".to_string(),
                    DataValue::ParameterMask(
                        vec!["a3".to_string(), "b1".to_string()]
                            .into_iter()
                            .collect::<BTreeSet<String>>(),
                    ),
                ),
            ].into_iter()
                .collect::<BTreeMap<String, DataValueDescriptive>>(),
        };
        let parameterset2 = ParameterSet {
            name: "overlay".to_string(),
            descriptions: vec![(
                "b1".to_string(),
                ParameterDescription {
                    caption: "Parameter B 1".to_string(),
                    data_type: DataType::UInt8,
                    storage: StorageType::Channel,
                    override_option: OverrideOption::Forbid,
                },
            )].into_iter()
                .collect::<BTreeMap<String, ParameterDescription>>(),
            values: vec![("b1".to_string(), DataValue::UInt8(14u8))]
                .into_iter()
                .collect::<BTreeMap<String, DataValueDescriptive>>(),
        };
        let job1 = Job {
            commands: vec![
                Command {
                    caption: "init job command 1".to_string(),
                    conditions: vec![Condition {
                        caption: "init job cmd 1 condition 1".to_string(),
                        exit_job: true,
                        parameters: vec![("a", "a1"), ("b", "b1")]
                            .into_iter()
                            .map(|(k, v)| (k.to_string(), v.to_string()))
                            .collect(),
                        command_type: "equals".to_string(),
                    }],
                    command_type: "wait".to_string(),
                    parameters: vec![("a", "b1"), ("b", "a1")]
                        .into_iter()
                        .map(|(k, v)| (k.to_string(), v.to_string()))
                        .collect(),
                },
                Command {
                    caption: "init job command 2".to_string(),
                    conditions: Vec::new(),
                    command_type: "wait".to_string(),
                    parameters: vec![("a", "b1")]
                        .into_iter()
                        .map(|(k, v)| (k.to_string(), v.to_string()))
                        .collect(),
                },
            ],
        };
        let job2 = Job {
            commands: vec![
                Command {
                    caption: "measurement job command 1".to_string(),
                    conditions: Vec::new(),
                    command_type: "wait".to_string(),
                    parameters: BTreeMap::new(),
                },
                Command {
                    caption: "measurement job command 2".to_string(),
                    conditions: Vec::new(),
                    command_type: "wait".to_string(),
                    parameters: BTreeMap::new(),
                },
            ],
        };
        let jobset = JobSet {
            parameters: vec![parameterset1, parameterset2],
            jobs: vec![
                ("init".to_string(), job1),
                ("measurement".to_string(), job2),
            ].into_iter()
                .collect(),
            channels: vec![
                (
                    "a1".to_string(),
                    ChannelAssignment {
                        capability: "motor".to_string(),
                        channel: "speed".to_string(),
                    },
                ),
                (
                    "a3".to_string(),
                    ChannelAssignment {
                        capability: "adc".to_string(),
                        channel: "voltage".to_string(),
                    },
                ),
            ].into_iter()
                .collect(),
        };
        let deserialized = serde_json::from_value(json.clone()).unwrap();

        assert_eq!(jobset, deserialized);

        let serialized = serde_json::to_value(&jobset).unwrap();
        assert_eq!(serialized, json);
    }
}