#![deny(missing_docs)]

//! Compilation of XIO jobsets for deployment on a device.

#[macro_use]
extern crate failure;

extern crate bidir_map;
extern crate xio_base_datatypes;
extern crate xio_hwdb;
extern crate xio_instructionset;
extern crate xio_jobset;

mod error;

use base::{HasDataType, HasStorageType, IsInStorageType};
use bidir_map::BidirMap;
use error::CodeLocation;
pub use error::{Error, ErrorKind};
use failure::Fail;
use std::collections::{BTreeMap, BTreeSet};
use std::ops::Shl;
use xio_base_datatypes as base;
use xio_hwdb as hwdb;
use xio_instructionset as instructionset;
use xio_jobset as jobset;

type Result<T> = std::result::Result<T, error::Error>;

/// A compiled jobset which can be deployed to a XIO device.
#[derive(Debug)]
pub struct CompiledJobSet {
    /// The parameters of the jobset.
    pub parameters: CompiledParameterSet,
    /// The job index mapping (which job gets placed at which index).
    pub job_mapping: BidirMap<String, u16>,
    /// The jobs compiled to XIO job commands.
    pub jobs: BTreeMap<String, Vec<u16>>,
}

impl CompiledJobSet {
    /// Build a vector of XIO job commands.
    pub fn build_jobs(&self) -> Result<Vec<Vec<u16>>> {
        Ok((0..self.jobs.len())
            .map(|i| {
                let name = self
                    .job_mapping
                    .get_by_second(&(i as u16))
                    .ok_or_else(|| ErrorKind::ProgrammerError {
                        msg: format!(
                            "Expected job at index {} not found",
                            i
                        ),
                    })?
                    .to_string();
                self.jobs
                    .get(&name)
                    .ok_or_else(|| {
                        ErrorKind::ProgrammerError {
                            msg: format!(
                                "Expected job at index {:?} not found",
                                name
                            ),
                        }.into()
                    })
                    .map(|v| v.clone())
            })
            .collect::<Result<Vec<_>>>()?)
    }
}

/// A compiled parameter set to be used in a XIO jobset.
#[derive(Debug)]
pub struct CompiledParameterSet {
    /// The parameter index mapping (index where parameters are stored).
    pub parameter_mapping: BidirMap<String, u16>,
    /// The statically assigned parameter values.
    pub parameters: BTreeMap<String, base::ParameterValueRaw>,
    /// The parameter values that get set before jobs are run.
    pub runtime_parameters: BTreeMap<String, base::DataValueRaw>,
    /// The XIO capabilities which are assigned to this job.
    pub assigned_capabilities: BTreeSet<String>,
}

impl CompiledParameterSet {
    /// Build a vector of all static parameter values.
    pub fn build_request_parameters(
        &self,
    ) -> Result<Vec<base::ParameterValueRaw>> {
        Ok((0..self.parameter_mapping.len())
            .map(|i| {
                let name = self
                    .parameter_mapping
                    .get_by_second(&(i as u16))
                    .ok_or_else(|| ErrorKind::ProgrammerError {
                        msg: format!(
                            "Expected parameter at index {} not found",
                            i
                        ),
                    })?
                    .to_string();
                self.parameters
                    .get(&name)
                    .ok_or_else(|| {
                        ErrorKind::MappedParameterNotFound {
                            name: name.to_string(),
                        }.into()
                    })
                    .map(|v| v.clone())
            })
            .collect::<Result<Vec<_>>>()?)
    }

    /// Build map of all parameters that get set before jobs are run.
    pub fn build_runtime_parameters(
        &self,
    ) -> Result<BTreeMap<u16, base::DataValueRaw>> {
        Ok(self
            .runtime_parameters
            .iter()
            .map(|(k, v)| {
                let index = self
                    .parameter_mapping
                    .get_by_first(&k.to_string())
                    .ok_or_else(|| ErrorKind::ProgrammerError {
                        msg: format!(
                            "Runtime parameter at index {} not found",
                            k
                        ),
                    })?;
                Ok((*index, v.clone()))
            })
            .collect::<Result<BTreeMap<u16, base::DataValueRaw>>>()?)
    }
}

/// A XIO hardware target for which a jobset gets compiled.
#[derive(Debug)]
pub struct HardwareTarget {
    /// The id of the device.
    pub id: String,
    /// The description of the device.
    pub description: hwdb::HardwareBoardDescription,
    /// The modules description of the device.
    pub modules: BTreeMap<String, hwdb::Module>,
    /// The instruction set which is used for compilation.
    pub instructions: instructionset::InstructionMap,
}

impl HardwareTarget {
    /// If successful, returns the referenced value, and a string containing
    /// the id of the capability that contains the channel.
    fn channel_reference(
        &self,
        name: &str,
        assignment: &jobset::ChannelAssignment,
        hardware_board: &str,
        required_datatype: &base::DataType,
    ) -> Result<(base::ParameterValueRaw, String)> {
        let assigned_capability = assignment.capability.to_string();
        let capability = self
            .description
            .capabilities
            .get(&assigned_capability)
            .ok_or_else(|| ErrorKind::CapabilityNotFound {
                name: assignment.capability.to_string(),
                parameter_name: name.to_string(),
                hardware_board: hardware_board.to_string(),
            })?;
        let module = self.modules.get(&capability.module).ok_or_else(
            || ErrorKind::ModuleDescriptionNotFound {
                name: capability.module.to_string(),
                parameter_name: name.to_string(),
                capability_name: assignment.capability.to_string(),
                hardware_board: hardware_board.to_string(),
            },
        )?;
        let channel_index = module
            .channels
            .iter()
            .position(|c| c.id == assignment.channel)
            .ok_or_else(|| ErrorKind::ModuleChannelNotFound {
                name: assignment.channel.to_string(),
                module_name: capability.module.to_string(),
                parameter_name: name.to_string(),
            })?;
        let channel = &module.channels[channel_index];
        if channel.channel_type != *required_datatype {
            return Err(ErrorKind::ChannelDataTypeMismatch {
                index: channel_index as u16,
                name: assignment.channel.to_string(),
                module_name: capability.module.to_string(),
                required_datatype: required_datatype.clone(),
                found_datatype: channel.channel_type.clone(),
                parameter_name: name.to_string(),
            }.into());
        }

        let reference = base::ModuleChannelReference {
            module_id: capability.id,
            channel_id: channel_index as u16,
        };

        use base::DataType::*;
        use base::ParameterValue::{
            BooleanChannel, Int16Channel, Int32Channel, Int64Channel,
            Int8Channel, ParameterMaskChannel, UInt16Channel,
            UInt32Channel, UInt64Channel, UInt8Channel,
        };
        match channel.channel_type {
            Boolean => {
                Ok((BooleanChannel(reference), assigned_capability))
            }
            Int8 => Ok((Int8Channel(reference), assigned_capability)),
            Int16 => Ok((Int16Channel(reference), assigned_capability)),
            Int32 => Ok((Int32Channel(reference), assigned_capability)),
            Int64 => Ok((Int64Channel(reference), assigned_capability)),
            UInt8 => Ok((UInt8Channel(reference), assigned_capability)),
            UInt16 => Ok((UInt16Channel(reference), assigned_capability)),
            UInt32 => Ok((UInt32Channel(reference), assigned_capability)),
            UInt64 => Ok((UInt64Channel(reference), assigned_capability)),
            ParameterMask => {
                Ok((ParameterMaskChannel(reference), assigned_capability))
            }
            Invalid => Err(ErrorKind::InvalidDataType {
                name: name.to_string(),
            }.into()),
        }
    }
}

/// A trait for XIO jobset compilation.
pub trait XioJobSetCompile {
    /// Compile a jobset.
    fn compile(&self, target: &HardwareTarget) -> Result<CompiledJobSet>;
}

impl XioJobSetCompile for jobset::JobSet {
    fn compile(&self, target: &HardwareTarget) -> Result<CompiledJobSet> {
        let compiled_parameters =
            compile_parameters(&self.parameters, target, &self.channels)?;
        compile_jobs(&self.jobs, compiled_parameters, &target.instructions)
    }
}

struct ParameterEntry {
    description_layer: String,
    description: jobset::ParameterDescription,
    value: Option<base::DataValueDescriptive>,
}

#[derive(Default)]
struct ParameterBuilder {
    entries: BTreeMap<String, ParameterEntry>,
}

impl ParameterBuilder {
    fn overlay(
        mut self,
        layer: &jobset::ParameterSet,
    ) -> Result<ParameterBuilder> {
        for (ref k, ref v) in &layer.descriptions {
            // check that the layer only contains new parameter descriptions
            if let Some(d) = self.entries.get(&k.to_string()) {
                return Err(ErrorKind::ParameterAlreadyDescribed {
                    name: k.to_string(),
                    original_layer: d.description_layer.to_string(),
                    offending_layer: layer.name.to_string(),
                }.into());
            }
            let description = (*v).clone();
            // check that parameter value overrides are respected
            {
                use base::OverrideOption::*;
                use base::StorageType::*;
                use ErrorKind::*;
                match (
                    layer.values.contains_key(&k.to_string()),
                    &description.override_option,
                    &description.storage,
                ) {
                    (true, &Enforce, _) => {
                        // override-enforced parameters *must not* be defined
                        // on the same overlay
                        return Err(ParameterOverrideEnforceNotRespected {
                            name: k.to_string(),
                            layer: layer.name.to_string(),
                        }.into());
                    }
                    (false, &Forbid, &Fixed) => {
                        // override-forbid parameters *must* be defined
                        // on the same overlay
                        return Err(ParameterOverrideForbidNotSatisfied {
                            name: k.to_string(),
                            layer: layer.name.to_string(),
                        }.into());
                    }
                    _ => {}
                }
            }
            let entry = ParameterEntry {
                description_layer: layer.name.to_string(),
                description,
                value: None,
            };
            self.entries.insert(k.to_string(), entry);
        }
        for (ref k, ref v) in &layer.values {
            if let Some(d) = self.entries.get_mut(&k.to_string()) {
                // check for the variables that were defined in a lower
                // level overlay
                if d.description.override_option
                    == base::OverrideOption::Forbid
                    && d.description_layer != layer.name
                {
                    return Err(ErrorKind::ParameterOverrideNotAllowed {
                        name: k.to_string(),
                        layer: layer.name.to_string(),
                    }.into());
                }
                // check parameter types
                use base::TryConvertTo;
                let t = &d.description.data_type;

                let value = v.try_convert_to(t).map_err(|e| {
                    e.context(ErrorKind::ParameterTypeMismatch {
                        name: k.to_string(),
                        defined_type: (*t).clone(),
                        defined_layer: d.description_layer.clone(),
                        value: (**v).clone(),
                        value_layer: layer.name.to_string(),
                    })
                })?;
                d.value = Some(value);
            } else {
                return Err(ErrorKind::ParameterNotYetDescribed {
                    name: k.to_string(),
                    layer: layer.name.to_string(),
                }.into());
            }
        }
        Ok(self)
    }

    fn finalize(
        self,
        target: &HardwareTarget,
        mapping: &BTreeMap<String, jobset::ChannelAssignment>,
    ) -> Result<CompiledParameterSet> {
        // Move the referenced parameters to the front, so the
        // probability to cover them in a mask is much higher
        let referenced_parameters = self
            .entries
            .iter()
            .filter_map(|(_, v)| v.value.clone())
            .filter_map(|v| {
                if let base::DataValue::ParameterMask(ref list) = v {
                    Some(list.clone())
                } else {
                    None
                }
            })
            .flat_map(|list| list.into_iter())
            .collect::<BTreeSet<String>>();
        let mut non_referenced_parameters = self
            .entries
            .keys()
            .map(|v| v.to_string())
            .collect::<BTreeSet<String>>();

        for p in &referenced_parameters {
            if non_referenced_parameters.take(p).is_none() {
                return Err(ErrorKind::MappedParameterNotFound {
                    name: p.to_string(),
                }.into());
            }
        }

        let parameter_mapping = referenced_parameters
            .into_iter()
            .chain(non_referenced_parameters.into_iter())
            .enumerate()
            .map(|(i, v)| (v.to_string(), i as u16))
            .collect::<BidirMap<String, u16>>();
        let mut parameters = BTreeMap::new();
        let mut runtime_parameters = BTreeMap::new();
        let mut assigned_capabilities = BTreeSet::new();

        for (ref k, ref v) in &self.entries {
            let (value, runtime_value) = match v.description.storage {
                base::StorageType::Fixed => {
                    if let Some(ref v) = v.value {
                        (
                            base::ParameterValueRaw::from(
                                v.to_raw(&parameter_mapping)?,
                            ),
                            None,
                        )
                    } else {
                        return Err(
                            ErrorKind::ParameterWithFixedStorageAndNoValue {
                                name: k.to_string(),
                            }.into(),
                        );
                    }
                }
                base::StorageType::Channel => {
                    let assignment = mapping
                        .get(&k.to_string())
                        .ok_or_else(|| {
                            ErrorKind::ParameterNotMappedInHardwareAssignment {
                            name: k.to_string(),
                            hardware_board: target.id.to_string(),
                        }
                        })?;
                    let (reference, assigned_capability) = target
                        .channel_reference(
                            k,
                            assignment,
                            &target.id,
                            &v.description.data_type,
                        )?;
                    assigned_capabilities.insert(assigned_capability);
                    (
                        reference,
                        match v.value {
                            Some(ref v) => {
                                Some(v.to_raw(&parameter_mapping)?)
                            }
                            None => None,
                        },
                    )
                }
            };
            parameters.insert(k.to_string(), value);
            if let Some(r) = runtime_value {
                // TODO: check that the parameter type matches
                runtime_parameters.insert(
                    k.to_string(),
                    r, // TODO: convert with &parameter_mapping if necessary
                );
            }
        }

        Ok(CompiledParameterSet {
            parameter_mapping,
            parameters,
            runtime_parameters,
            assigned_capabilities,
        })
    }
}

fn compile_parameters(
    parameters: &[jobset::ParameterSet],
    target: &HardwareTarget,
    mapping: &BTreeMap<String, jobset::ChannelAssignment>,
) -> Result<CompiledParameterSet> {
    let mut builder = ParameterBuilder::default();
    for layer in parameters {
        builder = builder.overlay(&layer)?;
    }
    builder.finalize(target, mapping)
}

fn compile_jobs(
    jobs: &BTreeMap<String, xio_jobset::Job>,
    parameters: CompiledParameterSet,
    instructions: &instructionset::InstructionMap,
) -> Result<CompiledJobSet> {
    let jobs = jobs
        .iter()
        .map(|(k, v)| {
            Ok((
                k.to_string(),
                compile_job(v, &parameters, instructions, k)?,
            ))
        })
        .collect::<Result<BTreeMap<String, Vec<u16>>>>()?;
    let job_mapping = jobs
        .keys()
        .enumerate()
        .map(|(i, n)| (n.to_string(), i as u16))
        .collect::<BidirMap<String, u16>>();
    Ok(CompiledJobSet {
        jobs,
        job_mapping,
        parameters,
    })
}

fn compile_job(
    job: &xio_jobset::Job,
    parameters: &CompiledParameterSet,
    instructions: &instructionset::InstructionMap,
    job_name: &str,
) -> Result<Vec<u16>> {
    let mut commands = Vec::new();
    for (command_index, command) in job.commands.iter().enumerate() {
        let command_index = command_index as u16;
        let location = CodeLocation::Command {
            job: job_name.to_string(),
            command_index,
            command_caption: command.caption.to_string(),
        };
        commands.extend(compile_command_with_conditions(
            command,
            parameters,
            instructions,
            &location,
        )?);
    }
    Ok(commands)
}

fn compile_command_with_conditions(
    command: &xio_jobset::Command,
    parameters: &CompiledParameterSet,
    instructions: &instructionset::InstructionMap,
    location: &CodeLocation,
) -> Result<Vec<u16>> {
    let instruction = instructions.get(&command.command_type).ok_or_else(
        || ErrorKind::InstructionNotFound {
            name: command.command_type.to_string(),
            location: location.clone(),
        },
    )?;

    use instructionset::InstructionCategory::*;
    match instruction.category() {
        CommandWithoutTimeExtent if command.conditions.is_empty() => {
            compile_command(command, parameters, instruction, location)
        }
        CommandWithoutTimeExtent => {
            Err(ErrorKind::CommandWithoutTimeExtentButConditions {
                location: location.clone(),
                command_type: command.command_type.to_string(),
            }.into())
        }
        CommandWithTimeExtent if !command.conditions.is_empty() => {
            let mut commands = compile_command(
                command,
                parameters,
                instruction,
                location,
            )?;
            commands.extend(compile_conditions(
                &command.conditions,
                parameters,
                instructions,
                location,
            )?);
            Ok(commands)
        }
        CommandWithTimeExtent => {
            Err(ErrorKind::CommandWithTimeExtentButNoConditions {
                location: location.clone(),
                command_type: command.command_type.to_string(),
            }.into())
        }
        Condition => Err(ErrorKind::FoundConditionInCommands {
            location: location.clone(),
            command_type: command.command_type.to_string(),
        }.into()),
        Invalid => Err(ErrorKind::InvalidInstructionCategory {
            location: location.clone(),
            command_type: command.command_type.to_string(),
        }.into()),
    }
}

trait HasParameters {
    fn get_parameters(&self) -> &BTreeMap<String, String>;
}

trait HasFlags {
    fn get_flags(&self) -> u8 {
        0u8
    }
}

impl HasParameters for jobset::Command {
    fn get_parameters(&self) -> &BTreeMap<String, String> {
        &self.parameters
    }
}

impl HasParameters for jobset::Condition {
    fn get_parameters(&self) -> &BTreeMap<String, String> {
        &self.parameters
    }
}

impl HasFlags for jobset::Command {}

impl HasFlags for jobset::Condition {
    fn get_flags(&self) -> u8 {
        if self.exit_job {
            0b0001u8
        } else {
            0b0000u8
        }
    }
}

fn compile_command<T: HasParameters + HasFlags>(
    command: &T,
    parameters: &CompiledParameterSet,
    instruction: &instructionset::Instruction,
    location: &CodeLocation,
) -> Result<Vec<u16>> {
    // extract required parameter information
    let mut param_groups = BTreeMap::new();
    let mut param_names = BTreeSet::new();

    for param in &instruction.parameters {
        let group = param_groups
            .entry(param.group.to_string())
            .or_insert_with(BTreeSet::new);
        group.insert(param.id.to_string());
        param_names.insert(param.id.to_string());
    }
    // empty group means the params are actually not in a group
    param_groups.remove(&"".to_string());

    // verify that the parameter names are the same as the required
    // parameters
    let effective_param_names = command
        .get_parameters()
        .keys()
        .map(|k| k.to_string())
        .collect::<BTreeSet<String>>();
    if effective_param_names != param_names {
        return Err(ErrorKind::WrongParameters {
            found: effective_param_names,
            required: param_names,
            location: location.clone(),
        }.into());
    }

    // verify that each group contains parameters of the same type only
    for (group, params) in param_groups {
        let params = params
            .iter()
            .map(|k| {
                Ok(command
                    .get_parameters()
                    .get(&k.to_string())
                    .ok_or_else(|| ErrorKind::ParameterNotFound {
                        name: k.to_string(),
                    })?)
            })
            .collect::<Result<Vec<_>>>()?
            .into_iter()
            .map(|k| {
                Ok((
                    k.to_string(),
                    parameters.parameters.get(k).ok_or_else(|| {
                        ErrorKind::ParameterNotFound {
                            name: k.to_string(),
                        }
                    })?,
                ))
            })
            .collect::<Result<BTreeMap<String, &base::ParameterValueRaw>>>(
            )?
            .into_iter()
            .map(|(k, v)| (k, v.data_type()))
            .collect::<BTreeMap<String, base::DataType>>();
        if params
            .values()
            .cloned()
            .collect::<BTreeSet<base::DataType>>()
            .len() > 1
        {
            return Err(ErrorKind::ParametersInGroupAreOfDifferentTypes {
                parameters: params
                    .keys()
                    .map(|s| s.to_string())
                    .collect::<BTreeSet<String>>(),
                location: location.clone(),
                group,
            }.into());
        }
    }

    let code = u16::from(command.get_flags()).shl(12) | instruction.code;
    let mut chunks = vec![code];

    for param in &instruction.parameters {
        let id = &param.id;
        let param_index = command.get_parameters()[id].to_string();
        let value = parameters.parameters[&param_index].clone();
        if !value.is_in_storage(&param.storage) {
            return Err(ErrorKind::ParameterStorageDoesNotFit {
                name: param_index.to_string(),
                location: location.clone(),
                required_storage: param.storage.clone(),
                found_storage: value.storage_type(),
            }.into());
        }
        let param_index = parameters
            .parameter_mapping
            .get_by_first(&param_index)
            .ok_or_else(|| ErrorKind::ParameterNotFound {
                name: id.to_string(),
            })?;
        chunks.push(*param_index);
    }

    Ok(chunks)
}

fn compile_conditions(
    conditions: &[xio_jobset::Condition],
    parameters: &CompiledParameterSet,
    instructions: &instructionset::InstructionMap,
    location: &CodeLocation,
) -> Result<Vec<u16>> {
    let mut commands = Vec::new();
    for (condition_index, condition) in conditions.iter().enumerate() {
        let condition_index = condition_index as u16;
        let location = location.clone().with_condition(
            condition_index,
            condition.caption.to_string(),
        );
        let instruction = instructions
            .get(&condition.command_type)
            .ok_or_else(|| ErrorKind::InstructionNotFound {
                name: condition.command_type.to_string(),
                location: location.clone(),
            })?;
        let command = compile_command(
            condition,
            parameters,
            instruction,
            &location,
        )?;
        commands.extend(command);
    }
    Ok(commands)
}