use super::*;

#[test]

fn test_unconnected_component_error() {

    compile_and_create_component("

    primitive interact_with_noone() {

        u8[] array = { 5 };

        auto value = array[1];

    }", "interact_with_noone", no_args());

}

#[test]

fn test_connected_uncommunicating_component_error() {

    compile_and_create_component("

    primitive crashing_and_burning(out<u32> unused) {

        u8[] array = { 1337 };

        auto value = array[1337];

    }

    primitive sitting_idly_waiting(in<u32> never_providing) {

        sync auto a = get(never_providing);

    }

    composite constructor() {

        channel a -> b;

        new sitting_idly_waiting(b);

        new crashing_and_burning(a);

    }", "constructor", no_args())

}

#[test]

fn test_connected_communicating_component_error() {

    compile_and_create_component("

    primitive send_and_fail(out<u32> tx) {

        u8[] array = {};

        sync {

            put(tx, 0);

            array[0] = 5;

        }

    }

    primitive receive_once(in<u32> rx) {

        sync auto a = get(rx);

    }

    composite constructor() {

        channel a -> b;

        new send_and_fail(a);

        new receive_once(b);

    }

    ", "constructor", no_args())

}

use crate::protocol::*;

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

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

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

mod error_handling;

const DEBUG_LOGGING: bool = true;

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

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

        .expect("successful compilation");

    let runtime = Runtime::new(NUM_THREADS, DEBUG_LOGGING, protocol)

        .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);

    rt.inner.enqueue_work(key);

}

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");

    let rt = Runtime::new(1, true, pd).unwrap();

    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) {

            u32 inside_index = 0;

            sync while (inside_index < inside_loops) {

                put(o, inside_index);

                inside_index += 1;

            }

            outside_index += 1;

        }

    }

    primitive receiver(in<u32> i, u32 outside_loops, u32 inside_loops) {

        u32 outside_index = 0;

        while (outside_index < outside_loops) {

            u32 inside_index = 0;

            sync while (inside_index < inside_loops) {

                auto val = get(i);

                while (val != inside_index) {} // infinite loop if incorrect value is received

                inside_index += 1;

            }

            outside_index += 1;

        }

    }

    composite constructor() {

        channel o_orom -> i_orom;

        channel o_mrom -> i_mrom;

        channel o_ormm -> i_ormm;

        channel o_mrmm -> i_mrmm;

        // one round, one message per round

        new sender(o_orom, 1, 1);

        new receiver(i_orom, 1, 1);

        // 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");

    let rt = Runtime::new(3, true, pd).unwrap();

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

}

#[test]

fn test_intermediate_messenger() {

    let pd = ProtocolDescription::parse(b"

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