modelverse/integration/code/ps_simulator.alc

include "primitives.alh"
include "services.alh"
include "modelling.alh"
include "object_operations.alh"
include "io.alh"
include "json.alh"

Boolean function main(model : Element):
	String pdevs_client_taskname
    String the_output
    String the_input
    String devs_model
    String simulation_state
    String command
    Element input_for_devs_sim
    Element params
    Element parsed_value
    Element curr_output
    Element constructed_output
    Element to_output
    Element new_items
    Element curr_param
    Element keys
    Element curr_key
    Element devs_instances
    Element curr_devs_instance
    Element generators
    Element curr_convbelt
    Element splitted_key
    Element connected_items
    Element curr_item
    Element curr_value
    String curr_id
    Element temp_dict
    Boolean item_found
    String devs_name
    
    pdevs_client_taskname = input()
    log("(PS) Got task name from console!")
    log("(PS) " + pdevs_client_taskname)
    
    simulation_state = "paused"
    
    while (True):
        if (has_input()):
            the_input = input()
            log("(PS) Got input from console!")
            log("(PS) " + cast_value(the_input))
            if (bool_not(is_physical_string(the_input))):
                the_input = cast_value(the_input)
            parsed_value = json_deserialize(the_input)
            log("(PS) Parsed input!")
            log("(PS) " + list_to_string(parsed_value))
            // TODO: look at simulation state: figure out what to send to simulator (either nothing or big_step). Also save the end condition probably.
            command = list_read(parsed_value, 0)
            if (command == "big_step"):
                if (simulation_state == "paused"):
                    simulation_state = "big_step"
                    input_for_devs_sim = list_create()
                    list_append(input_for_devs_sim, "big_step")
                    list_append(input_for_devs_sim, list_read(parsed_value, 1))
            give_input_to_other(pdevs_client_taskname, json_serialize(input_for_devs_sim))
        if (other_has_output(pdevs_client_taskname)):
            the_output = get_output_from_other(pdevs_client_taskname)
            log("(PS) Got output from pdevs simulator!")
            log("(PS) " + the_output)
            parsed_value = json_deserialize(the_output)
            log("(PS) Parsed output!")
            // log("(PS) " + dict_to_string(parsed_value))
            constructed_output = list_create()
            if (bool_or((cast_string(parsed_value['name']) == 'new_states'), (cast_string(parsed_value['name']) == 'all_states'))):
                // curr_output = detect_convbelt_new_item(parsed_value, model)
                
                log("(PS) ENTER detect_convbelt_new_item")
                    
                params = parsed_value['params']
                curr_output = dict_create()
                keys = dict_keys(params[1])
                while (read_nr_out(keys) > 0):
                    curr_key = set_pop(keys)
                    log("(PS) curr_key = " + cast_string(curr_key))
                    if (cast_string(parsed_value['name']) == 'new_states'):
                        curr_value = params[1][curr_key]
                    else:
                        curr_value = params[1][curr_key][1]
                    log("(PS) curr_value = " + dict_to_string(curr_value))
                    log(cast_value(dict_in(curr_value, 'product')))
                    if (bool_and(dict_in(curr_value, 'product'), bool_not(is_physical_none(curr_value['product'])))):
                        devs_instances = allInstances(model, 'ParallelDEVS/DEVSInstance')
                        while (read_nr_out(devs_instances) > 0):
                            curr_devs_instance = set_pop(devs_instances)
                            splitted_key = string_split(curr_key, ".")
                            log("(PS) checking key = " + cast_string(list_read(splitted_key, list_len(splitted_key) - 1)))
                            log("(PS) checking name = " + cast_string(read_attribute(model, curr_devs_instance, "name")))
                            if (cast_string(list_read(splitted_key, list_len(splitted_key) - 1)) == cast_string(read_attribute(model, curr_devs_instance, "name"))):
                                break!
                            if (read_nr_out(devs_instances) == 0):
                                log("(PS) We shouldn't reach this point..")
                        log("(PS) found: " + cast_string(curr_devs_instance))
                        curr_convbelt = set_pop(allAssociationOrigins(model, curr_devs_instance, "PS2DEVS_instancelink"))
                        if (read_type(model, curr_convbelt) == "ProductionSystemRuntime/ConveyorBelt"):
                            connected_items = allAssociationDestinations(model, curr_convbelt, "ProductionSystemRuntime/Conv_To_I")
                            curr_id = cast_string(curr_value['product']['id'])
                            item_found = False
                            while (read_nr_out(connected_items) > 0):
                                if (cast_value(set_pop(connected_items)) == curr_id):
                                    item_found = True
                                    log("(PS) Item " + curr_id + " found...")
                                    break!
                            if (bool_not(item_found)):
                                log("(PS) Item not found, creating...")
                                instantiate_node(model, ("ProductionSystemRuntime/" + cast_string(curr_value['product']['type'])), curr_id)
                                instantiate_attribute(model, curr_id, "broken", curr_value['product']['broken'])
                                instantiate_link(model, "ProductionSystemRuntime/Conv_To_I", "", curr_convbelt, curr_id)
                                temp_dict = dict_create()
                                dict_add_fast(temp_dict, 'type', ("ProductionSystemRuntime/" + cast_string(curr_value['product']['type'])))
                                dict_add_fast(temp_dict, 'name', curr_id)
                                dict_add_fast(temp_dict, 'broken', curr_value['product']['broken'])
                                dict_add_fast(curr_output, curr_convbelt, temp_dict)
                                
                if (read_nr_out(dict_keys(curr_output)) > 0):
                    new_items = dict_create()
                    dict_add_fast(new_items, "new_items", curr_output)
                    list_append(constructed_output, new_items)
            if (list_len(constructed_output) > 0):
                to_output = dict_create()
                dict_add_fast(to_output, 'name', 'state_update')
                dict_add_fast(to_output, 'parameters', constructed_output)
                output(json_serialize(to_output))
            else:
                // TODO temporary
                output(the_output)
        sleep(0.05)
        
Element function detect_convbelt_new_item(state_update: Element, model: Element):
    log("(PS) ENTER detect_convbelt_new_item")

    Element params
    Element curr_param
    Element keys
    Element curr_key
    Element devs_instances
    Element curr_devs_instance
    Element generators
    Element curr_convbelt
    Element splitted_key
    Element connected_items
    Element curr_item
    Element curr_value
    String curr_id
    Element to_output
    Element temp_dict
    Boolean item_found
    String devs_name
        
    params = state_update['params']
    to_output = dict_create()
    keys = dict_keys(params[1])
    while (read_nr_out(keys) > 0):
        curr_key = set_pop(keys)
        log("(PS) curr_key = " + cast_string(curr_key))
        curr_value = curr_param[curr_key]
        if (dict_in(curr_value, 'product')):
            devs_instances = allInstances(model, 'ParallelDEVS/DEVSInstance')
            while (read_nr_out(devs_instances) > 0):
                curr_devs_instance = set_pop(devs_instances)
                splitted_key = string_split(curr_key, ".")
                log("(PS) checking key = " + cast_string(list_read(splitted_key, list_len(splitted_key) - 1)))
                log("(PS) checking name = " + cast_string(read_attribute(model, curr_devs_instance, "name")))
                if (cast_string(list_read(splitted_key, list_len(splitted_key) - 1)) == cast_string(read_attribute(model, curr_devs_instance, "name"))):
                    break!
                if (read_nr_out(devs_instances) == 0):
                    log("(PS) We shouldn't reach this point..")
            curr_convbelt = set_pop(allAssociationOrigins(model, curr_devs_instance, "PS2DEVS_instancelink"))
            if (read_type(model, curr_convbelt) == "ProductionSystemRuntime/ConveyorBelt"):
                connected_items = allAssociationDestinations(model, curr_convbelt, "ProductionSystemRuntime/Conv_To_I")
                curr_id = cast_string(curr_value['product']['id'])
                item_found = False
                while (read_nr_out(connected_items) > 0):
                    if (cast_value(set_pop(connected_items)) == curr_id):
                        item_found = True
                        log("(PS) Item " + curr_id + " found...")
                        break!
                if (bool_not(item_found)):
                    log("(PS) Item not found, creating...")
                    instantiate_node(model, ("ProductionSystemRuntime/" + cast_string(curr_value['product']['type'])), curr_id)
                    instantiate_attribute(model, curr_id, "broken", curr_value['product']['broken'])
                    instantiate_link(model, "ProductionSystemRuntime/Conv_To_I", "", curr_convbelt, curr_id)
                    temp_dict = dict_create()
                    dict_add_fast(temp_dict, 'type', ("ProductionSystemRuntime/" + cast_string(curr_value['product']['type'])))
                    dict_add_fast(temp_dict, 'name', curr_id)
                    dict_add_fast(temp_dict, 'broken', curr_value['product']['broken'])
                    dict_add_fast(to_output, curr_convbelt, temp_dict)
    return to_output!
        
Boolean function is_big_step_done(state_update: Element):
    return True!
    
Boolean function is_small_step_done(state_update: Element):
    return True!