use super::vec_storage::VecStorage;

use crate::common::*;

use crate::runtime::endpoint::EndpointExt;

use crate::runtime::endpoint::EndpointInfo;

use crate::runtime::endpoint::{Endpoint, Msg, SetupMsg};

use crate::runtime::errors::EndpointErr;

use crate::runtime::errors::MessengerRecvErr;

use crate::runtime::errors::PollDeadlineErr;

use crate::runtime::MessengerState;

use crate::runtime::Messengerlike;

use crate::runtime::ReceivedMsg;

use crate::runtime::{ProtocolD, ProtocolS};

use std::net::SocketAddr;

use std::sync::Arc;

pub enum Coupling {

    Active,

    Passive,

}

#[derive(Debug)]

struct Family {

    parent: Option<Port>,

    fn bind(&mut self, coupling: Coupling, addr: SocketAddr) -> OutPort {

        self.bindings.push(Binding { coupling, polarity: Polarity::Putter, addr });

        OutPort(Port(self.bindings.len() - 1))

    }

}

#[derive(Debug, Clone)]

pub enum ConnectErr {

    BindErr(SocketAddr),

    NewSocketErr(SocketAddr),

    AcceptErr(SocketAddr),

    ConnectionShutdown(SocketAddr),

    PortKindMismatch(Port, SocketAddr),

    EndpointErr(Port, EndpointErr),

    PollInitFailed,

    PollingFailed,

    Timeout,

}

#[derive(Debug)]

struct Component {

    protocol: Arc<ProtocolD>,

    port_set: HashSet<Port>,

    identifier: Arc<[u8]>,

}

impl From<PollDeadlineErr> for ConnectErr {

    fn from(e: PollDeadlineErr) -> Self {

        use PollDeadlineErr as P;

        match e {

            P::PollingFailed => Self::PollingFailed,

            P::Timeout => Self::Timeout,

        }

    }

}

impl From<MessengerRecvErr> for ConnectErr {

    fn from(e: MessengerRecvErr) -> Self {

        use MessengerRecvErr as M;

        match e {

            M::PollingFailed => Self::PollingFailed,

            M::EndpointErr(port, err) => Self::EndpointErr(port, err),

        }

    }

}

impl Connecting {

    fn random_controller_id() -> ControllerId {

        type Bytes8 = [u8; std::mem::size_of::<ControllerId>()];

        let mut bytes = Bytes8::default();

    ) -> Result<Connected, ConnectErr> {

        // 1. try and create a connection from these bindings with self immutable.

        let connected = self.new_connected(controller_id, timeout)?;

        // 2. success! drain self and return

        self.bindings.clear();

        Ok(connected)

    }

    pub fn connect(&mut self, timeout: Option<Duration>) -> Result<Connected, ConnectErr> {

        self.connect_using_id(Self::random_controller_id(), timeout)

    }

}

#[derive(Debug)]

pub struct Connected {

    native_ports: HashSet<Port>,

    controller_id: ControllerId,

    channel_index_stream: ChannelIndexStream,

    endpoint_exts: VecStorage<EndpointExt>,

    components: VecStorage<Component>,

    family: Family,

    ephemeral: Ephemeral,

}

#[derive(Debug, Default)]

struct Ephemeral {

    bit_matrix: BitMatrix,

}

impl Connected {

    pub fn new_component(

        &mut self,

        protocol: &Arc<ProtocolD>,

        identifier: &Arc<[u8]>,

        moved_port_list: &[Port],

    ) -> Result<(), MainComponentErr> {

        //////////////////////////////////////////

        // 1. try and create a new component (without mutating self)

        use MainComponentErr::*;

        let moved_port_set = {

            let mut set: HashSet<Port> = Default::default();

            for &port in moved_port_list.iter() {

                if !self.native_ports.contains(&port) {

                    return Err(CannotMovePort(port));

                }

                if !set.insert(port) {

                    return Err(DuplicateMovedPort(port));

                }

            }

            set

        };

        // moved_port_set is disjoint to native_ports

        let expected_polarities = protocol.component_polarities(identifier)?;

        if moved_port_list.len() != expected_polarities.len() {

            return Err(WrongNumberOfParamaters { expected: expected_polarities.len() });

        }

        // correct polarity list

        for (param_index, (&port, &expected_polarity)) in

            moved_port_list.iter().zip(expected_polarities.iter()).enumerate()

        {

            let polarity =

                self.endpoint_exts.get_occupied(port.0).ok_or(UnknownPort(port))?.info.polarity;

            if polarity != expected_polarity {

                return Err(WrongPortPolarity { param_index, port });

            }

        }

        let component = Component {

            port_set: moved_port_set,

            protocol: protocol.clone(),

            identifier: identifier.clone(),

            state,

        };

        //////////////////////////////

        // success! mutate self and return Ok

        self.native_ports.retain(|e| !component.port_set.contains(e));

        self.components.new_occupied(component);

        Ok(())

    }

    pub fn new_channel(&mut self) -> (OutPort, InPort) {

        assert!(self.endpoint_exts.len() <= std::u32::MAX as usize - 2);

        let channel_id = ChannelId {

            controller_id: self.controller_id,

            channel_index: self.channel_index_stream.next(),

        };

        let [e0, e1] = Endpoint::new_memory_pair();

        let kp = self.endpoint_exts.new_occupied(EndpointExt {

            info: EndpointInfo { channel_id, polarity: Putter },

            endpoint: e0,

        });

        let kg = self.endpoint_exts.new_occupied(EndpointExt {

            info: EndpointInfo { channel_id, polarity: Getter },

            endpoint: e1,

        });

        (OutPort(Port(kp)), InPort(Port(kg)))

    }

    pub fn sync_set(&mut self, _inbuf: &mut [u8], _ops: &mut [PortOpRs]) -> Result<(), ()> {

        Ok(())

    }

    pub fn sync_subsets(

        &mut self,

        _inbuf: &mut [u8],

        _ops: &mut [PortOpRs],

        bit_subsets: &[&[usize]],

    ) -> Result<usize, ()> {

        for (batch_index, bit_subset) in bit_subsets.iter().enumerate() {

            println!("batch_index {:?}", batch_index);

            let chunk_iter = bit_subset.iter().copied();

            for index in BitChunkIter::new(chunk_iter) {

                println!("  index {:?}", index);

            }

        }

        Ok(0)

    }

}

macro_rules! bitslice {

    ($( $num:expr  ),*) => {{

        &[0 $( | (1usize << $num)  )*]

    }};

}

#[test]

fn api_connecting() {

    let addrs: [SocketAddr; 3] = [

        "127.0.0.1:8888".parse().unwrap(),

        "127.0.0.1:8889".parse().unwrap(),

        "127.0.0.1:8890".parse().unwrap(),

    ];

    lazy_static::lazy_static! {

        static ref PROTOCOL: Arc<ProtocolD> = {

            static PDL: &[u8] = b"

            primitive sync(in i, out o) {

                while(true) synchronous {

                    put(o, get(i));

                }

            }

            ";

            Arc::new(ProtocolD::parse(PDL).unwrap())

        };

    }

    const TIMEOUT: Option<Duration> = Some(Duration::from_secs(1));

    let handles = vec![

        std::thread::spawn(move || {

            let identifier = b"sync".to_vec().into();

        }),

        std::thread::spawn(move || {

            let mut connecting = Connecting::default();

            let _a: OutPort = connecting.bind(Coupling::Active, addrs[0]);

            let _b: InPort = connecting.bind(Coupling::Passive, addrs[1]);

            let _c: InPort = connecting.bind(Coupling::Active, addrs[2]);

            let _connected = connecting.connect(TIMEOUT).unwrap();

        }),

        std::thread::spawn(move || {

            let mut connecting = Connecting::default();

            let _a: OutPort = connecting.bind(Coupling::Passive, addrs[2]);

            let _connected = connecting.connect(TIMEOUT).unwrap();

        }),

    ];

    for h in handles {

        h.join().unwrap();

    }

}

use crate::common::*;

use std::alloc::Layout;

/// Given an iterator over BitChunk Items, iterates over the indices (each represented as a u32) for which the bit is SET,

/// treating the bits in the BitChunk as a contiguous array.

/// e.g. input [0b111000, 0b11] gives output [3, 4, 5, 32, 33].

/// observe that the bits per chunk are ordered from least to most significant bits, yielding smaller to larger usizes.

/// assumes chunk_iter will yield no more than std::u32::MAX / 32 chunks

pub const fn usize_bytes() -> usize {

    std::mem::size_of::<usize>()

}

pub const fn usize_bits() -> usize {

    usize_bytes() * 8

}

pub const fn usizes_for_bits(bits: usize) -> usize {

    (bits + (usize_bits() - 1)) / usize_bits()

}

type Chunk = usize;

type BitIndex = usize;

pub(crate) struct BitChunkIter<I: Iterator<Item = Chunk>> {

    cached: usize,

    chunk_iter: I,

    next_bit_index: BitIndex,

}

impl<I: Iterator<Item = Chunk>> BitChunkIter<I> {

    pub fn new(chunk_iter: I) -> Self {

        // Consequences:

        // 1. our next_bit_index is always off by usize_bits() (we correct for it in Self::next) (no additional overhead)

        // 2. we cache Chunk and not Option<Chunk>, because chunk_iter.next() is only called in Self::next.

        Self { chunk_iter, next_bit_index: 0, cached: 0 }

    }

}

impl<I: Iterator<Item = Chunk>> Iterator for BitChunkIter<I> {

    type Item = BitIndex;

    fn next(&mut self) -> Option<Self::Item> {

        let mut chunk = self.cached;

        // loop until either:

        // 1. there are no more Items to return, or

        // 2. chunk encodes 1+ Items, one of which we will return.

        while chunk == 0 {

            // chunk has no bits set! get the next one...

            chunk = self.chunk_iter.next()?;

            // ... and jump self.next_bit_index to the next multiple of usize_bits().

            self.next_bit_index = (self.next_bit_index + usize_bits()) & !(usize_bits() - 1);

        }

        // there exists 1+ set bits in chunk

        // assert(chunk > 0);

            // this loop is unrolled with release optimizations

            let n_least_significant_mask = (1 << n) - 1;

            if chunk & n_least_significant_mask == 0 {

                // no 1 set within 0..n least significant bits.

                self.next_bit_index += n;

                chunk >>= n;

            }

            n /= 2;

        }

        // least significant bit of chunk is 1. Item to return is known.

        // assert(chunk & 1 == 1)

        // prepare our state for the next time Self::next is called.

        // Overwrite self.cached such that its shifted state is retained,

        // and jump over the bit whose index we are about to return.

        self.next_bit_index += 1;

        self.cached = chunk >> 1;

        // returned index is usize_bits() smaller than self.next_bit_index because we use an

        // off-by-usize_bits() encoding to avoid having to cache an Option<usize>.

        Some(self.next_bit_index - 1 - usize_bits())

    }

}

/*  --properties-->

     ___ ___ ___ ___

    |___|___|___|___|

  | |___|___|___|___|

  | |___|___|___|___|

  | |___|___|___|___|

  |

  V

 entity chunks (groups of size usize_bits())

*/

// TODO newtypes Entity and Property

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

}

impl From<[u32; 2]> for Pair {

    fn from([entity, property]: [u32; 2]) -> Self {

        Pair { entity, property }

    }

}

impl Default for BitMatrix {

    fn default() -> Self {

        Self::new(Pair { entity: 0, property: 0 })

    }

}

pub struct BitMatrix {

    buffer: *mut usize,

    bounds: Pair,

    layout: Layout, // layout of the currently-allocated buffer

}

impl Drop for BitMatrix {

    fn drop(&mut self) {

        unsafe {

            // ?

            std::alloc::dealloc(self.buffer as *mut u8, self.layout);

        }

    }

}

                        write!(f, "{}", c)?;

                        chunk >>= 1;

                    }

                    write!(f, "_")?;

                }

                Ok(())

            }

        }

        let row_chunks = BitMatrix::row_chunks(self.bounds.property as usize);

        let iter = (0..row_chunks).map(move |property| FmtRow { me: self, property });

        f.debug_list().entries(iter).finish()

    }

}

impl BitMatrix {

    #[inline]

    const fn row_of(entity: usize) -> usize {

        entity / usize_bits()

    }

    #[inline]

    const fn row_chunks(property_bound: usize) -> usize {

        property_bound

    }

    #[inline]

    const fn column_chunks(entity_bound: usize) -> usize {

    }

    #[inline]

    fn offsets_unchecked(&self, at: Pair) -> [usize; 2] {

        let o_in = at.entity as usize % usize_bits();

        let row = Self::row_of(at.entity as usize);

        let row_chunks = self.bounds.property as usize;

        let o_of = row * row_chunks + at.property as usize;

        [o_of, o_in]

    }

    // returns a u32 which has bits 000...000111...111

    // for the last JAGGED chunk given the column size

    // if the last chunk is not jagged (when entity_bound % 32 == 0)

    // None is returned,

    // otherwise Some(x) is returned such that x & chunk would mask out

    // the bits NOT in 0..entity_bound

    fn last_row_chunk_mask(entity_bound: u32) -> Option<usize> {

        let zero_prefix_len = entity_bound as usize % usize_bits();

        if zero_prefix_len == 0 {

            None

        } else {

            Some(!0 >> (usize_bits() - zero_prefix_len))

        }

    }

    fn assert_within_bounds(&self, at: Pair) {

        assert!(at.entity < self.bounds.entity);

        assert!(at.property < self.bounds.property);

    }

    fn layout_for(total_chunks: usize) -> std::alloc::Layout {

        unsafe {

            // this layout is ALWAYS valid:

            // 1. size is always nonzero

            // 2. size is always a multiple of 4 and 4-aligned

            Layout::from_size_align_unchecked(usize_bytes() * total_chunks.max(1), usize_bytes())

        }

    }

    /////////

    }

        let total_chunks = Self::row_chunks(bounds.property as usize)

            * Self::column_chunks(bounds.entity as usize);

        let layout = Self::layout_for(total_chunks);

        let buffer;

        unsafe {

            buffer = std::alloc::alloc(layout) as *mut usize;

            buffer.write_bytes(0u8, total_chunks);

        };

        Self { buffer, bounds, layout }

    }

        self.assert_within_bounds(at);

        let [o_of, o_in] = self.offsets_unchecked(at);

        unsafe { *self.buffer.add(o_of) |= 1 << o_in };

    }

        self.assert_within_bounds(at);

        let [o_of, o_in] = self.offsets_unchecked(at);

        unsafe { *self.buffer.add(o_of) &= !(1 << o_in) };

    }

        self.assert_within_bounds(at);

        let [o_of, o_in] = self.offsets_unchecked(at);

        unsafe { *self.buffer.add(o_of) & 1 << o_in != 0 }

    }

        let row_chunks = Self::row_chunks(self.bounds.property as usize);

        let column_chunks = Self::column_chunks(self.bounds.entity as usize);

        let mut ptr = self.buffer;

        for _row in 0..column_chunks {

            let slice;

            unsafe {

                let slicey = std::slice::from_raw_parts_mut(ptr, row_chunks);

                slice = std::mem::transmute(slicey);

                ptr = ptr.add(row_chunks);

            }

            chunk_mut_fn(slice);

        }

        if let Some(mask) = Self::last_row_chunk_mask(self.bounds.entity) {

            // TODO TEST

            let mut ptr = unsafe { self.buffer.add((column_chunks - 1) * row_chunks) };

            for _ in 0..row_chunks {

                unsafe {

                    *ptr &= mask;

                    ptr = ptr.add(1);

                }

            }

        }

    }

    /// given:

    /// 1. a buffer to work with

    /// 2. a _fold function_ for combining the properties of a given entity

    ///    and returning a new derived property (working )

        &'a self,

        buf: &'b mut Vec<usize>,

        mut fold_fn: impl FnMut(&'b [BitChunk]) -> BitChunk,

    ) -> impl Iterator<Item = u32> + 'b {

        let buf_start = buf.len();

        let row_chunks = Self::row_chunks(self.bounds.property as usize);

        let column_chunks = Self::column_chunks(self.bounds.entity as usize);

        let mut ptr = self.buffer;

        for _row in 0..column_chunks {

            let slice;

            unsafe {

                let slicey = std::slice::from_raw_parts(ptr, row_chunks);

                slice = std::mem::transmute(slicey);

                ptr = ptr.add(row_chunks);

            }

            let chunk = fold_fn(slice);

            buf.push(chunk.0);

        }

        if let Some(mask) = Self::last_row_chunk_mask(self.bounds.entity) {

            *buf.iter_mut().last().unwrap() &= mask;

        }

        BitChunkIter::new(buf.drain(buf_start..)).map(|x| x as u32)

    }

}

use derive_more::*;

#[derive(

    Debug, Copy, Clone, BitAnd, Not, BitOr, BitXor, BitAndAssign, BitOrAssign, BitXorAssign,

)]

#[repr(transparent)]

pub struct BitChunk(usize);

impl BitChunk {

    const fn any(self) -> bool {

    }

    const fn all(self) -> bool {

    }

}

#[test]

fn matrix_test() {

    let mut m = BitMatrix::new(Pair { entity: 70, property: 3 });

    m.set([2, 0].into());

    m.set([40, 1].into());

    m.set([40, 2].into());

    m.set([40, 0].into());

    for i in (0..40).step_by(7) {

        m.unset([i, 0].into());

    }

    m.unset([62, 0].into());

    let mut buf = vec![];

    for index in m.iter_entities_where(&mut buf, move |p| p[1]) {

        println!("index {}", index);

    }

}