Taunt(u8),

    HogSay(String),

    Heartbeat,

    TeamControlGained(String),

    TeamControlLost(String),

}

#[derive(Debug, PartialEq)]

pub enum UnorderedEngineMessage {

    ChatMessage(String),

    TeamMessage(String),

    Error(String),

    PauseToggled,

    GameType(u8),

    Synced(SyncedEngineMessage, u32),

    Unsynced(UnsyncedEngineMessage),

    Unordered(UnorderedEngineMessage),

    Config(ConfigEngineMessage),

}

macro_rules! em {

    [$msg: expr] => {

        vec![($msg) as u8]

    };

}

macro_rules! ems {

    [$msg: expr, $param: expr] => {

        {

            let mut v = vec![($msg) as u8];

            v.extend(String::into_bytes($param.to_string()).iter());

            v

        }

    };

impl SyncedEngineMessage {

    fn to_bytes(&self) -> Vec<u8> {

        use self::KeystrokeAction::*;

        use self::SyncedEngineMessage::*;

        match self {

            Left(Press) => em!['L'],

            Left(Release) => em!['l'],

            Right(Press) => em!['R'],

            Right(Release) => em!['r'],

            Up(Press) => em!['U'],

            Up(Release) => em!['u'],

            Down(Press) => em!['D'],

            Down(Release) => em!['d'],

            Precise(Press) => em!['Z'],

            Precise(Release) => em!['z'],

            Attack(Press) => em!['A'],

            Attack(Release) => em!['a'],

            NextTurn => em!['N'],

            Switch => em!['S'],

            Timer(t) => vec!['0' as u8 + t],

            Slot(s) => vec!['~' as u8, *s],

            SetWeapon(s) => vec!['~' as u8, *s],

            Put(x, y) => unimplemented!(),

            CursorMove(x, y) => unimplemented!(),

            HighJump => em!['J'],

            LongJump => em!['j'],

            Skip => em![','],

            TeamControlGained(str) => ems!['g', str],

            TeamControlLost(str) => ems!['f', str],

            Taunt(s) => vec!['t' as u8, *s],

            HogSay(str) => ems!['h', str],

            Heartbeat => em!['+'],

            TimeWrap => unreachable!(),

        }

}

impl UnsyncedEngineMessage {

    fn to_bytes(&self) -> Vec<u8> {

        use self::UnsyncedEngineMessage::*;

        match self {

            TeamControlGained(str) => ems!['G', str],

            TeamControlLost(str) => ems!['F', str],

        }

    }

}

impl UnorderedEngineMessage {

impl ConfigEngineMessage {

    fn to_bytes(&self) -> Vec<u8> {

        unimplemented!()

    }

}

impl EngineMessage {

    pub const MAX_LEN: u16 = 49215;

    fn to_unwrapped(&self) -> Vec<u8> {

        use self::EngineMessage::*;

        match self {

            Unknown => unreachable!("you're not supposed to construct such messages"),

            Empty => unreachable!("you're not supposed to construct such messages"),

            Synced(SyncedEngineMessage::TimeWrap, _) => vec!['#' as u8, 0xff, 0xff],

            Synced(msg, timestamp) => {

                let mut v = msg.to_bytes();

                v.push((*timestamp / 256) as u8);

                v.push(*timestamp as u8);

                v

            }

            Unsynced(msg) => msg.to_bytes(),

            Unordered(msg) => msg.to_bytes(),

            Config(msg) => msg.to_bytes(),

        }

    }

    pub fn to_bytes(&self) -> Vec<u8> {

        let mut unwrapped = self.to_unwrapped();

        let mut size = unwrapped.len();

        if size > EngineMessage::MAX_LEN as usize - 2 {

            size = EngineMessage::MAX_LEN as usize - 2;

            unwrapped.truncate(size);

        }

        if size < 64 {

            unwrapped.insert(0, size as u8);

        } else {

            size -= 64;

            unwrapped.insert(0, (size / 256 + 64) as u8);

            unwrapped.insert(1, size as u8);

        }

        unwrapped

    }

}

#[test]

fn message_contruction() {

    assert_eq!(

        EngineMessage::Synced(SyncedEngineMessage::TimeWrap, 0).to_bytes(),

        vec![3, '#' as u8, 255, 255]

    );

    assert_eq!(

        EngineMessage::Synced(SyncedEngineMessage::NextTurn, 258).to_bytes(),

        vec![3, 'N' as u8, 1, 2]

    );

}