use command::CmdSet;
use crc;
use encrypt;
use header::{HEADER_LENGTH, Header};
use std::io::{self, Read};
use std::u16;
use types::FromBytes;

struct FrameBuffer {
    data: [u8; 4096],
    pos: usize,
    cursor: usize,
}

impl FrameBuffer {
    fn new() -> FrameBuffer {
        FrameBuffer {
            data: [0; 4096],
            pos: 0,
            cursor: 0,
        }
    }

    fn size(&self) -> usize {
        self.cursor - self.pos
    }

    fn data(&self) -> &[u8] {
        &self.data[self.pos..self.cursor]
    }

    fn shift(&mut self, n: usize) -> &[u8] {
        let s = &self.data[self.pos..self.pos + n];
        self.pos += n;
        s
    }

    fn unshift(&mut self, n: usize) {
        self.pos -= n;
    }

    fn read<T: Read>(&mut self, reader: &mut T) -> bool {
        let res = reader.read(&mut self.data[self.cursor..]);
        match res {
            Ok(i) => {
                self.cursor += i;
                i != 0
            }
            Err(e) => {
                match e.kind() {
                    io::ErrorKind::TimedOut => false,
                    _ => panic!(e),
                }
            }
        }
    }

    fn rewind(&mut self) {
        if self.data.len() - self.cursor >= 1024 {
            return;
        }
        let data_len = self.cursor - self.pos;

        if data_len > 0 {
            let (left, right) = self.data.split_at_mut(self.pos);
            (left[0..data_len]).clone_from_slice(&right[0..data_len]);
        }
        self.cursor = data_len;
        self.pos = 0;
    }
}

/// Track session status.
#[derive(Debug, Clone, Copy)]
pub enum SessionStatus {
    /// Session can be taken.
    Idle,
    /// Session is using.
    Using,
    /// Session Succeed.
    Succeed,
    /// Session failed
    Failed,
}

impl From<bool> for SessionStatus {
    fn from(v: bool) -> SessionStatus {
        match v {
            true => SessionStatus::Succeed,
            false => SessionStatus::Failed,
        }
    }
}

#[derive(Debug, Clone, Copy)]
struct Session {
    seq: u16,
    status: SessionStatus,
    cmd: Option<CmdSet>,
}

impl Default for Session {
    fn default() -> Session {
        Session {
            seq: 0,
            status: SessionStatus::Idle,
            cmd: None,
        }
    }
}

impl Session {
    fn is_idle(&self) -> bool {
        match self.status {
            SessionStatus::Idle => true,
            _ => false,
        }
    }
}

/// Parse frame and manage sessions.
///
/// ## Example
///
/// ```rust
/// use open_protocol::frame::FrameManager;
/// use std::io::Cursor;
///
/// let key = b"94c6f2d6272d4e20bdf9d0674d06e0c8".to_vec();
/// let mut data = Cursor::new(vec![170, 32, 0, 34, 46, 0, 0, 0, 1, 0, 102,
///                                 147, 8, 189, 154, 56, 14, 13, 111, 111,
///                                 152, 146, 172, 61, 185, 208, 45, 222,
///                                 63, 16, 0, 122]);
///
/// let mut manager = FrameManager::new(key);
/// manager.read(&mut data);
/// let _ = manager.parse();
/// ```
pub struct FrameManager {
    sessions: [Session; 32],
    seq: u16,
    buf: FrameBuffer,
    key: Vec<u8>,
}

impl FrameManager {
    pub fn new(key: Vec<u8>) -> Self {
        FrameManager {
            sessions: [Default::default(); 32],
            seq: 1,
            buf: FrameBuffer::new(),
            key: key,
        }
    }

    pub fn key(&self) -> &[u8] {
        &self.key
    }

    pub fn take_session(&mut self, seq: u16, cmd: CmdSet) -> Option<u8> {
        self.sessions[2..]
            .iter_mut()
            .enumerate()
            .filter(|&(_, &mut session)| session.is_idle())
            .next()
            .map(|(i, session)| {
                     session.seq = seq;
                     session.status = SessionStatus::Using;
                     session.cmd = Some(cmd);
                     (i + 2) as u8
                 })
    }

    pub fn reset_sessions(&mut self) {
        for s in self.sessions.iter_mut().filter(|s| !s.is_idle()) {
            *s = Default::default();
        }
    }

    pub fn reset_session(&mut self, id: u8) {
        let s = &mut self.sessions[id as usize];
        *s = Default::default();
    }

    pub fn mark_session(&mut self, id: u8, succeed: bool) {
        self.sessions[id as usize].status = From::from(succeed)
    }

    pub fn session_cmd(&self, id: u8) -> Option<CmdSet> {
        self.sessions[id as usize].cmd
    }

    pub fn session_succeed(&self, id: u8) -> bool {
        let session = &self.sessions[id as usize];
        match session.status {
            SessionStatus::Succeed => true,
            _ => false,
        }
    }

    pub fn get_session_status(&self, id: u8) -> &SessionStatus {
        &self.sessions[id as usize].status
    }

    pub fn read<T: Read>(&mut self, reader: &mut T) -> bool {
        self.buf.read(reader)
    }

    pub fn get_seq(&mut self) -> u16 {
        let seq = self.seq;
        if self.seq == u16::max_value() {
            self.seq = 0;
        }
        self.seq += 1;
        seq
    }

    pub fn parse(&mut self) -> Option<(Header, Vec<u8>)> {
        if self.buf.size() < 12 {
            self.buf.rewind();
            return None;
        }
        let header = Header::from_bytes(self.buf.data()).unwrap();
        if !header.verify() {
            self.buf.shift(1);
            return Some((header, vec![]));
        }

        let len = header.length();

        if self.buf.size() < len {
            self.buf.rewind();
            return None;
        }

        let frame = {
            let header_len = len - 4;
            let frame = self.buf.shift(len);
            if crc::crc32(&frame[0..header_len]) != u32::from_bytes(&frame[header_len..]).unwrap() {
                vec![]
            } else {
                let mut fr = frame.to_vec();
                if header.enc() == 1 {
                    let decoded = encrypt::decode_data(&fr[12..header_len], &self.key);
                    (&mut fr[12..header_len]).copy_from_slice(&decoded);
                }
                fr
            }
        };

        if frame.is_empty() {
            self.buf.unshift(len - HEADER_LENGTH);
        } else if header.is_ack() {
            let i = header.session_id() as usize;
            // drop wrong frame
            if self.sessions[i].seq != header.seq() {
                return Some((header, vec![]));
            }
        }
        Some((header, frame))
    }
}