from sccd.runtime.statecharts_core import Event
import sccd.runtime.socket2event as socket2event
import modelverse_SCCD
import time

controller = modelverse_SCCD.Controller()
socket2event.boot_translation_service(controller)

ID = 0

# Exceptions
class ModelverseException(Exception):
    pass

class UnknownError(ModelverseException):
    pass

class UnknownIdentifier(ModelverseException):
    pass

class CompilationError(ModelverseException):
    pass

class NoSuchAttribute(ModelverseException):
    pass

class UnknownModel(ModelverseException):
    pass

class ConnectionError(ModelverseException):
    pass

class ModelExists(ModelverseException):
    pass

class PermissionDenied(ModelverseException):
    pass

class InvalidMode(ModelverseException):
    pass

class InterfaceMismatch(ModelverseException):
    pass

class UnknownMetamodellingHierarchy(ModelverseException):
    pass

def run_controller():
    try:
        controller.start()
    finally:
        controller.stop()

def _next_ID():
    global ID
    ID += 1
    return ID

def INPUT(action, context, parameters):
    print("Executing " + str(action))
    print("Parameters: " + str(parameters))
    print("In context: " + str(context))
    controller.addInput(Event("action", "action_in", [action, _next_ID(), context, parameters]))

def OUTPUT():
    while 1:
        response = responses.fetch(-1)
        print("Got response with name: " + str(response.name))
        if response.name == "result":
            print("Value: " + str(response.parameters[1]))
            return response.parameters[1]
        elif response.name == "exception":
            print("Exception: " + str(response.parameters))
            if response.parameters[1] == "UnknownIdentifier":
                raise UnknownIdentifier()
            elif response.parameters[1] == "UnknownMetamodellingHierarchy":
                raise UnknownMetamodellingHierarchy()

def init(address_param="127.0.0.1:8001", timeout=20.0):
    INPUT("init", None, [address_param, timeout])
    return OUTPUT()

def login(username, password):
    INPUT("login", None, [username, password])
    return OUTPUT()

def model_list(location):
    INPUT("model_list", None, [location])
    return OUTPUT()

def model_add(model_name, metamodel_name, model_code=""):
    INPUT("model_add", None, [model_name, metamodel_name, model_code])
    return OUTPUT()

def model_delete(model_name):
    INPUT("model_delete", None, [model_name])
    return OUTPUT()

def model_list_full(location):
    INPUT("model_list_full", None, [location])
    return OUTPUT()

def verify(model_name, metamodel_name):
    INPUT("verify", None, [model_name, metamodel_name])
    return OUTPUT()

def model_overwrite(model_name, new_model):
    INPUT("model_overwrite", None, [model_name, new_model])
    return OUTPUT()

def disconnect():
    INPUT("disconnect", None, [])
    return OUTPUT()

def user_logout():
    INPUT("user_logout", None, [])
    return OUTPUT()

def user_delete():
    INPUT("user_delete", None, [])
    return OUTPUT()

def model_render(model_name, mapper_name):
    INPUT("model_render", None, [model_name, mapper_name])
    return OUTPUT()

def transformation_between(source, target):
    INPUT("transformation_between", None, [source, target])
    return OUTPUT()

def transformation_add_MT(source_metamodels, target_metamodels, operation_name, code, callback=None):
    INPUT("transformation_add_MT", None, [source_metamodels, target_metamodels, operation_name, code])
    context = OUTPUT()
    if callback is not None:
        callback(context)
    print("Callback finished; sending exit")
    INPUT("exit", context, [])
    return OUTPUT()

def transformation_add_AL(source_metamodels, target_metamodels, operation_name, code, callback=None):
    INPUT("transformation_add_AL", None, [source_metamodels, target_metamodels, operation_name, code])
    context = OUTPUT()
    if callback is not None:
        callback(context)
    INPUT("exit", context, [])
    return OUTPUT()

def transformation_add_MANUAL(source_metamodels, target_metamodels, operation_name, callback=None):
    INPUT("transformation_add_MANUAL", None, [source_metamodels, target_metamodels, operation_name])
    context = OUTPUT()
    if callback is not None:
        print("DOING CALLBACK FOR MANUAL")
        callback(context)
        print("CALLBACK FINISHED")
    INPUT("exit", context, [])
    return OUTPUT()

def transformation_execute_MT(operation_name, input_models_dict, output_models_dict, statechart=None):
    if statechart is not None:
        port_sc = statechart[0].addOutputListener(statechart[2])

    INPUT("transformation_execute_MT", None, [operation_name, input_models_dict, output_models_dict])
    context = OUTPUT()
    if statechart is not None:
        while 1:
            empty = True

            # Fetch output from the MV
            response = responses.fetch(0)
            if response is not None:
                print("Got response from MV: " + str(response))
                if response.name == "data_output":
                    # Got output of MV, so forward to SCCD
                    statechart[0].addInput(Event("input", statechart[1], response.parameters))
                elif response.name == "result":
                    # Finished execution, so continue and return result
                    statechart[0].addInput(Event("terminate", statechart[1], []))
                    return response.parameters[1]
                empty = False

            # Fetch output from the SC
            response = port_sc.fetch(0)
            if response is not None:
                print("Got response from SC: " + str(response))
                if response.name == "output":
                    controller.addInput(Event("data_input", "action_in", [response.parameters, context]))
                empty = False

            if empty:
                time.sleep(0.01)
    else:
        return OUTPUT()

def transformation_execute_AL(operation_name, input_models_dict, output_models_dict, statechart=None):
    if statechart is not None:
        port_sc = statechart[0].addOutputListener(statechart[2])

    INPUT("transformation_execute_AL", None, [operation_name, input_models_dict, output_models_dict])

    context = OUTPUT()
    if statechart is not None:
        while 1:
            empty = True

            # Fetch output from the MV
            response = responses.fetch(0)
            if response is not None:
                print("Got response from MV: " + str(response))
                if response.name == "data_output":
                    # Got output of MV, so forward to SCCD
                    statechart[0].addInput(Event("input", statechart[1], response.parameters))
                elif response.name == "result":
                    # Finished execution, so continue and return result
                    statechart[0].addInput(Event("terminate", statechart[1], []))
                    return response.parameters[1]
                empty = False

            # Fetch output from the SC
            response = port_sc.fetch(0)
            if response is not None:
                print("Got response from SC: " + str(response))
                if response.name == "output":
                    controller.addInput(Event("data_input", "action_in", [response.parameters, context]))
                empty = False

            if empty:
                time.sleep(0.01)
    else:
        return OUTPUT()

def transformation_execute_MANUAL(operation_name, input_models_dict, output_models_dict, callback=None):
    INPUT("transformation_execute_MANUAL", None, [operation_name, input_models_dict, output_models_dict])
    context = OUTPUT()
    if callback is not None:
        callback(context)
    INPUT("exit", context, [])
    return OUTPUT()

def permission_modify(model_name, permissions):
    INPUT("permission_modify", None, [model_name, permissions])
    return OUTPUT()

def permission_owner(model_name, permission):
    INPUT("permission_owner", None, [model_name, permission])
    return OUTPUT()

def permission_group(model_name, group):
    INPUT("permission_group", None, [model_name, group])
    return OUTPUT()

def group_create(group_name):
    INPUT("group_create", None, [group_name])
    return OUTPUT()

def group_delete(group_name):
    INPUT("group_delete", None, [group_name])
    return OUTPUT()

def group_owner_add(group_name, user_name):
    INPUT("group_owner_add", None, [group_name, user_name])
    return OUTPUT()

def group_owner_delete(group_name, user_name):
    INPUT("group_owner_delete", None, [group_name, user_name])
    return OUTPUT()

def group_join(group_name, user_name):
    INPUT("group_join", None, [group_name, user_name])
    return OUTPUT()

def group_kick(group_name, user_name):
    INPUT("group_kick", None, [group_name, user_name])
    return OUTPUT()

def group_list():
    INPUT("group_list", None, [])
    return OUTPUT()

def admin_promote(user_name):
    INPUT("admin_promote", None, [user_name])
    return OUTPUT()

def admin_demote(user_name):
    INPUT("admin_demote", None, [user_name])
    return OUTPUT()

def conformance_delete(model_name, metamodel_name):
    INPUT("conformance_delete", None, [model_name, metamodel_name])
    return OUTPUT()

def conformance_add(model_name, metamodel_name):
    INPUT("conformance_add", None, [model_name, metamodel_name])
    return OUTPUT()

def folder_create(folder_name):
    INPUT("folder_create", None, [folder_name])
    return OUTPUT()

def model_types(model_name):
    INPUT("model_types", None, [model_name])
    return OUTPUT()

def alter_context(model_name, metamodel_name):
    INPUT("alter_context", None, [model_name, metamodel_name])
    return OUTPUT()

def element_list(model_name, context=None):
    INPUT("element_list", context, [model_name])
    return OUTPUT()

def element_list_nice(model_name, context=None):
    INPUT("element_list_nice", context, [model_name])
    return OUTPUT()

def types(model_name, context=None):
    INPUT("types", context, [model_name])
    return OUTPUT()

def types_full(model_name, context=None):
    INPUT("types_full", context, [model_name])
    return OUTPUT()

def read_info(model_name, ID, context=None):
    INPUT("read_info", context, [model_name, ID])
    return OUTPUT()

def read_attrs(model_name, ID, context=None):
    INPUT("read_attrs", context, [model_name, ID])
    return OUTPUT()

def instantiate(model_name, typename, edge=None, ID="", context=None):
    INPUT("instantiate", context, [model_name, typename, edge, ID])
    return OUTPUT()

def delete_element(model_name, ID, context=None):
    INPUT("delete_element", context, [model_name, ID])
    return OUTPUT()

def attr_assign(model_name, ID, attr, value, context=None):
    INPUT("attr_assign", context, [model_name, ID, attr, value])
    return OUTPUT()

def attr_assign_code(model_name, ID, attr, code, context=None):
    INPUT("attr_assign_code", context, [model_name, ID, attr, code])
    return OUTPUT()

def attr_delete(model_name, ID, attr, context=None):
    INPUT("attr_delete", context, [model_name, ID, attr])
    return OUTPUT()

def read_outgoing(model_name, ID, typename, context=None):
    INPUT("read_outgoing", context, [model_name, ID, typename])
    return OUTPUT()

def read_incoming(model_name, ID, typename, context=None):
    INPUT("read_incoming", context, [model_name, ID, typename])
    return OUTPUT()

def read_association_source(model_name, ID, context=None):
    INPUT("read_association_source", context, [model_name, ID])
    return OUTPUT()

def read_association_destination(model_name, ID, context=None):
    INPUT("read_association_destination", context, [model_name, ID])
    return OUTPUT()

def connections_between(model_name, source, target, context=None):
    INPUT("connections_between", context, [model_name, source, target])
    return OUTPUT()

def define_attribute(model_name, node, attr_name, attr_type, context=None):
    INPUT("define_attribute", context, [model_name, node, attr_name, attr_type])
    return OUTPUT()

def all_instances(model_name, type_name, context=None):
    INPUT("all_instances", context, [model_name, type_name])
    return OUTPUT()

def process_execute(process_name, prefix, callbacks=None):
    # for all callbacks to SCs, start up the output port already
    sc_ports = {}

    for k, v in callbacks.items():
        if isinstance(v, (tuple, list)):
            # Is a statechart, so register already
            sc_ports[k] = v[0].addOutputListener(v[2])

    INPUT("process_execute", None, [process_name, prefix])

    #TODO this is all pseudo-code
    while 1:
        operation = OUTPUT()
        print("Operation: " + str(operation))
        if isinstance(operation, (list, tuple)):
            t, name, context = operation
            print("Executing operation of type %s with name %s in context %s" % (t, name, context))
            if t == "OP":
                if name in callbacks:
                    callbacks[name](context)
                INPUT("exit", context, [])
            elif t == "SC":
                if name in callbacks:
                    statechart = callbacks[name]
                    while 1:
                        empty = True

                        # Fetch output from the MV
                        response = responses.fetch(0)
                        if response is not None:
                            print("Got response from MV: " + str(response))
                            if response.name == "data_output":
                                # Got output of MV, so forward to SCCD
                                statechart[0].addInput(Event("input", statechart[1], response.parameters))
                            elif response.name == "result":
                                # Finished execution, so continue and return result
                                statechart[0].addInput(Event("terminate", statechart[1], []))
                                return response.parameters[1]
                            empty = False

                        # Fetch output from the SC
                        response = sc_ports[name].fetch(0)
                        if response is not None:
                            print("Got response from SC: " + str(response))
                            if response.name == "output":
                                controller.addInput(Event("data_input", "action_in", [response.parameters, context]))
                            empty = False

                        if empty:
                            time.sleep(0.01)
        else:
            if operation == "Finished":
                # Finished execution of the process, so exit
                return None
        
        # TODO monitor the new function and execute the correct callback

import threading
thrd = threading.Thread(target=run_controller)
thrd.daemon = True
thrd.start()

responses = controller.addOutputListener("action_out")
controller.addOutputListener("ready").fetch(-1)