//! Implements frame header.
//!
//! ## Frame Header
//!
//! | Field     | Bits | Desc                                                   |
//! |-----------+------+--------------------------------------------------------|
//! | sof       | 8    | Starting byte, fixed to be `0xaa`                      |
//! | length    | 10   | Length of the frame                                    |
//! | version   | 6    | Version of the frame header, filled by `0`             |
//! | session   | 5    | Frame session id                                       |
//! | ack       | 1    | Frame type: `0` cmd frame, `1` ack frame               |
//! | reserved0 | 2    | Reserved                                               |
//! | padding   | 5    | Length of padding data                                 |
//! | encoding  | 3    | Encryption type: `0` no encryption, `1` aes encryption |
//! | reserved1 | 24   | Reserved                                               |
//! | seq       | 16   | Frame sequence number                                  |
//! | crc16     | 16   | Crc16 of frame header                                  |
//!
//! Frame header has 12 bytes. The [Header](struct.Header.html) struct is defined to represent the
//! frame header.  When received a frame, the frame header should be
//! [verified](struct.Header.html#method.verify) before parsing the frame body.

use Error;

use Result;
use crc::crc16;
use std::io::Cursor;
use types::{FromBytes, IntoBytes};

pub const HEADER_LENGTH: usize = 12;
pub const SDK_SOF: u8 = 0xAA;

/// Represents the frame header.
///
/// ## Example
///
/// ```rust
/// use open_protocol::header::{Header, SDK_SOF};
///
/// let header = Header::build()
///     .sof(SDK_SOF)
///     .length(24)
///     .version(0)
///     .session_id(1)
///     .ack(false)
///     .enc(1)
///     .seq(4)
///     .crc()
///     .unwrap();
///
/// // Verify the header
/// header.verify();
///
/// // Get frame length
/// let frame_length = header.length();
/// frame_length == 24;
/// ```
#[derive(Debug, Clone, Copy)]
pub struct Header([u8; HEADER_LENGTH]);

/// Builder for building a [Header](struct.Header.html).
#[derive(Default)]
pub struct HeaderBuilder {
    sof: u8,
    length: u16,
    version: u8,
    session_id: u8,
    ack: u8,
    padding: u8,
    enc: u8,
    seq: u16,
}

impl HeaderBuilder {
    pub fn sof(mut self, sof: u8) -> Self {
        self.sof = sof;
        self
    }

    pub fn length(mut self, length: u16) -> Self {
        self.length = length;
        self
    }

    pub fn version(mut self, version: u8) -> Self {
        self.version = version;
        self
    }

    pub fn session_id(mut self, session_id: u8) -> Self {
        self.session_id = session_id;
        self
    }

    pub fn ack(mut self, is_ack: bool) -> Self {
        self.ack = if is_ack { 1 } else { 0 };
        self
    }

    pub fn padding(mut self, padding: u8) -> Self {
        self.padding = padding;
        self
    }

    pub fn enc(mut self, e: u8) -> Self {
        self.enc = e;
        self
    }

    pub fn seq(mut self, seq: u16) -> Self {
        self.seq = seq;
        self
    }

    /// Calculate crc16 of the header. And create a [Header](struct.Header.html).
    pub fn crc(self) -> Result<Header> {
        let mut header = Header([0; HEADER_LENGTH]);
        header.0[0] = self.sof;
        header.0[1] = self.length as u8;
        header.0[2] = (((self.length >> 8) as u8) & 0x3) | (self.version << 2);
        header.0[3] = (self.session_id & 0x1f) | (self.ack << 5);
        header.0[4] = (self.padding & 0x1f) | (self.enc << 5);
        (&mut header.0[8..10]).copy_from_slice(&self.seq.into_bytes()?);
        let crc = crc16(&header.0[..10]);
        (&mut header.0[10..12]).copy_from_slice(&crc.into_bytes()?);
        Ok(header)
    }
}

impl Header {
    /// Create a [HeaderBuiler](struct.HeaderBuilder.html) for building a frame header.
    pub fn build() -> HeaderBuilder {
        Default::default()
    }

    /// Starting byte. Fixed to be 0xAA.
    ///
    /// 8 bits.
    pub fn sof(&self) -> u8 {
        self.0[0]
    }

    /// The length of the frame.
    ///
    /// 10 bits.
    pub fn length(&self) -> usize {
        (self.0[1] as usize) | (((self.0[2] & 0x3) as usize) << 8)
    }

    /// The version of the frame header. Always zero.
    ///
    /// 6 bits.
    pub fn version(&self) -> u8 {
        self.0[2] >> 2
    }

    /// Ths session id of this frame.
    ///
    /// 5 bits.
    pub fn session_id(&self) -> u8 {
        self.0[3] & 0x1f
    }

    /// The type of this frame. `ture` means the frame is a ack frame,
    /// `false` means the frame is a cmd frame.
    ///
    /// 1 bit
    pub fn is_ack(&self) -> bool {
        ((self.0[3] >> 5) & 1) == 1
    }

    /// Always set to zero.
    ///
    /// 2 bits.
    pub fn reserved0(&self) -> u8 {
        self.0[3] >> 6
    }

    /// Padding data used by encryption logic.
    ///
    /// 5 bits.
    pub fn padding(&self) -> u8 {
        self.0[4] & 0x1f
    }

    /// Encryption type. 0 means no encryption, 1 means ase encryption.
    ///
    /// 3 bits.
    pub fn enc(&self) -> u8 {
        self.0[4] >> 5
    }

    /// Always set to zero.
    ///
    /// 24 bits.
    pub fn reserved1(&self) -> u32 {
        ((self.0[7] as u32) << 16) | ((self.0[6] as u32) << 8) | self.0[5] as u32
    }

    /// The frame sequence number.
    ///
    /// 16 bits.
    pub fn seq(&self) -> u16 {
        ((self.0[9] as u16) << 8) | (self.0[8] as u16)
    }

    /// CRC16 of the header of the frame.
    ///
    /// 16 bits.
    pub fn crc(&self) -> u16 {
        ((self.0[11] as u16) << 8) | (self.0[10] as u16)
    }

    /// Check whether the data is a valid frame header.
    pub fn verify(&self) -> bool {
        self.sof() == SDK_SOF && self.version() == 0 && self.reserved0() == 0 &&
        self.reserved1() == 0 && self.crc() == crc16(&self.0[..10])
    }
}

impl IntoBytes for Header {
    fn into_bytes(self) -> Result<Vec<u8>> {
        Ok(self.0.to_vec())
    }
}

impl FromBytes for Header {
    fn read_bytes(_: &mut Cursor<&[u8]>) -> Result<Header> {
        unimplemented!()
    }

    fn from_bytes(bytes: &[u8]) -> Result<Header> {
        if bytes.len() < 12 {
            Err(Error::codec("fail to deserialize input bytes"))
        } else {
            let mut data = [0u8; 12];
            data.clone_from_slice(&bytes[..12]);
            Ok(Header(data))
        }
    }
}