time::Duration,

};

pub use indexmap::{IndexMap, IndexSet};

pub use maplit::{hashmap, hashset};

pub use mio::{

    net::{TcpListener, TcpStream},

    Event, Evented, Events, Poll, PollOpt, Ready, Token,

};

pub use std::{

    collections::{hash_map::Entry, BTreeMap, HashMap, HashSet},

    convert::TryInto,

    net::SocketAddr,

    sync::Arc,

    time::Instant,

};

pub use Polarity::*;

///////////////////// DEFS /////////////////////

pub type Payload = Vec<u8>;

pub type ControllerId = u32;

pub type ChannelIndex = u32;

/// This is a unique identifier for a channel (i.e., port).

#[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]

pub struct ChannelId {

    pub(crate) controller_id: ControllerId,

    pub(crate) channel_index: ChannelIndex,

}

#[derive(Debug, Eq, PartialEq, Clone, Hash, Copy, Ord, PartialOrd)]

pub enum Polarity {

    Putter, // output port (from the perspective of the component)

    Getter, // input port (from the perspective of the component)

}

#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone, Debug)]

pub struct Key(u64);

pub enum MainComponentErr {

    NoSuchComponent,

    NonPortTypeParameters,

}

pub trait ProtocolDescription: Sized {

    type S: ComponentState<D = Self>;

    fn parse(pdl: &[u8]) -> Result<Self, String>;

    fn component_polarities(&self, identifier: &[u8]) -> Result<Vec<Polarity>, MainComponentErr>;

}

pub trait ComponentState: Sized + Clone {

    type D: ProtocolDescription;

    fn pre_sync_run<C: MonoContext<D = Self::D, S = Self>>(

        &mut self,

        runtime_ctx: &mut C,

        protocol_description: &Self::D,

    ) -> MonoBlocker;

    fn sync_run<C: PolyContext<D = Self::D>>(

        &mut self,

        runtime_ctx: &mut C,

        protocol_description: &Self::D,

    ) -> PolyBlocker;

}

#[derive(Debug, Clone)]

pub enum MonoBlocker {

    Inconsistent,

    ComponentExit,

    SyncBlockStart,

}

#[derive(Debug, Clone)]

pub enum PolyBlocker {

    Inconsistent,

    SyncBlockEnd,

    CouldntReadMsg(Key),

    CouldntCheckFiring(Key),

    PutMsg(Key, Payload),

}

pub trait MonoContext {

    type D: ProtocolDescription;

    type S: ComponentState<D = Self::D>;

    fn new_component(&mut self, moved_keys: HashSet<Key>, init_state: Self::S);

    fn new_channel(&mut self) -> [Key; 2];

    fn new_random(&mut self) -> u64;

}

pub trait PolyContext {

    type D: ProtocolDescription;

    fn is_firing(&mut self, ekey: Key) -> Option<bool>;

    fn read_msg(&mut self, ekey: Key) -> Option<&Payload>;

}