use crate::protocol::*;

use crate::runtime2::poll::{PollingThread, PollingThreadHandle};

use crate::runtime2::RtError;

use super::communication::Message;

use super::component::{Component, wake_up_if_sleeping, CompPDL, CompCtx};

use super::store::{ComponentStore, ComponentReservation, QueueDynMpsc, QueueDynProducer};

use super::scheduler::*;

#[derive(PartialOrd, PartialEq, Copy, Clone)]

pub enum LogLevel {

    Debug, // all logging (includes messages)

    Info, // rough logging

}

// -----------------------------------------------------------------------------

// Component

// -----------------------------------------------------------------------------

/// Key to a component. Type system somewhat ensures that there can only be one

/// of these. Only with a key one may retrieve privately-accessible memory for

/// a component. Practically just a generational index, like `CompId` is.

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

pub(crate) struct CompKey(pub u32);

    pub fn new(runtime: &'a RuntimeInner, polling: &'a PollingClient, id: u32, log_level: LogLevel) -> Self {

        return Self {

            runtime,

            polling,

            id,

            comp: 0,

            log_level,

        }

    }

    pub(crate) fn debug(&self, text: &str) {

        // TODO: Probably not always use colour

        }

    }

    pub(crate) fn info(&self, text: &str) {

            println!("[s:{:02}, c:{:03}] {}", self.id, self.comp, text);

        }

    }

    pub(crate) fn error(&self, text: &str) {

        // TODO: Probably not always use colour

        println!("[s:{:02}, c:{:03}] \x1b[0;31m{}\x1b[0m", self.id, self.comp, text);

    }

}

impl Scheduler {

    // public interface to thread

use crate::protocol::*;

use crate::protocol::eval::*;

use crate::runtime2::runtime::*;

use crate::runtime2::component::{CompCtx, CompPDL};

mod error_handling;

const NUM_THREADS: u32 = 4;

pub(crate) fn compile_and_create_component(source: &str, routine_name: &str, args: ValueGroup) {

    let protocol = ProtocolDescription::parse(source.as_bytes())

        .expect("successful compilation");

        .expect("successful runtime startup");

    create_component(&runtime, "", routine_name, args);

}

pub(crate) fn create_component(rt: &Runtime, module_name: &str, routine_name: &str, args: ValueGroup) {

    let prompt = rt.inner.protocol.new_component(

        module_name.as_bytes(), routine_name.as_bytes(), args

    ).expect("create prompt");

    let reserved = rt.inner.start_create_pdl_component();

    let ctx = CompCtx::new(&reserved);

    let component = Box::new(CompPDL::new(prompt, 0));

    let (key, _) = rt.inner.finish_create_pdl_component(reserved, component, ctx, false);

}

pub(crate) fn no_args() -> ValueGroup { ValueGroup::new_stack(Vec::new()) }

#[test]

fn test_component_creation() {

    let pd = ProtocolDescription::parse(b"

    primitive nothing_at_all() {

        s32 a = 5;

        auto b = 5 + a;

    }

    ").expect("compilation");

    for _i in 0..20 {

        create_component(&rt, "", "nothing_at_all", no_args());

    }

}

#[test]

fn test_component_communication() {

    let pd = ProtocolDescription::parse(b"

    primitive sender(out<u32> o, u32 outside_loops, u32 inside_loops) {

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

        // multiple rounds, one message per round

        new sender(o_mrom, 5, 1);

        new receiver(i_mrom, 5, 1);

        // one round, multiple messages per round

        new sender(o_ormm, 1, 5);

        new receiver(i_ormm, 1, 5);

        // multiple rounds, multiple messages per round

        new sender(o_mrmm, 5, 5);

        new receiver(i_mrmm, 5, 5);

    }").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_intermediate_messenger() {

    let pd = ProtocolDescription::parse(b"

    primitive receiver<T>(in<T> rx, u32 num) {

        auto index = 0;

        while (index < num) {

            sync { auto v = get(rx); }

            index += 1;

        }

        new receiver(rx_b, 3);

    }

    composite constructor() {

        new constructor_template<u16>();

        new constructor_template<u32>();

        new constructor_template<u64>();

        new constructor_template<s16>();

        new constructor_template<s32>();

        new constructor_template<s64>();

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_simple_select() {

    let pd = ProtocolDescription::parse(b"

    func infinite_assert<T>(T val, T expected) -> () {

        while (val != expected) { print(\"nope!\"); }

        return ();

    }

    primitive receiver(in<u32> in_a, in<u32> in_b, u32 num_sends) {

        }

    }

    composite constructor() {

        auto num_sends = 1;

        channel tx_a -> rx_a;

        channel tx_b -> rx_b;

        new sender(tx_a, num_sends);

        new receiver(rx_a, rx_b, num_sends);

        new sender(tx_b, num_sends);

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_unguarded_select() {

    let pd = ProtocolDescription::parse(b"

    primitive constructor_outside_select() {

        u32 index = 0;

        while (index < 5) {

            sync select { auto v = () -> print(\"hello\"); }

            index += 1;

        }

    }

    primitive constructor_inside_select() {

        u32 index = 0;

        while (index < 5) {

            sync select { auto v = () -> index += 1; }

        }

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor_outside_select", no_args());

    create_component(&rt, "", "constructor_inside_select", no_args());

}

#[test]

fn test_empty_select() {

    let pd = ProtocolDescription::parse(b"

    primitive constructor() {

        u32 index = 0;

        while (index < 5) {

            sync select {}

            index += 1;

        }

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_random_u32_temporary_thingo() {

    let pd = ProtocolDescription::parse(b"

    import std.random::random_u32;

    primitive random_taker(in<u32> generator, u32 num_values) {

        auto i = 0;

        while (i < num_values) {

            sync {

            }

            i += 1;

        }

    }

    composite constructor() {

        channel tx -> rx;

        auto num_values = 25;

        new random_u32(tx, 1, 100, num_values);

        new random_taker(rx, num_values);

    }

    ").expect("compilation");

    create_component(&rt, "", "constructor", no_args());

}

#[test]

fn test_tcp_socket_http_request() {

    let _pd = ProtocolDescription::parse(b"

    import std.internet::*;

    primitive requester(out<Cmd> cmd_tx, in<u8[]> data_rx) {

        print(\"*** TCPSocket: Sending request\");

        sync {

            put(cmd_tx, Cmd::Send(b\"GET / HTTP/1.1\\r\\n\\r\\n\"));

        sync put(tx, Cmd::Shutdown);

    }

    composite main() {

        auto num_rounds = 5;

        channel cmd_tx -> cmd_rx;

        channel data_tx -> data_rx;

        new database(cmd_rx, data_tx);

        new client(cmd_tx, data_rx, num_rounds);

    }

    ").expect("compilation");

    create_component(&rt, "", "main", no_args());

}