from core.execution import action
from core.execution.action.action import buildAction
from core.runtime.runtimecontract import buildPreRuntimeAttr, buildRuntimeAttr
from core.apirequest import executeRequest
from core.runtime.stopsignals import checkDependency
from core.execution.processregistry import registerProcess

def buildRecursive(definition, outputs):
    outputs = registerProcess(definition, outputs)

    responses = []
    from core.execution.executioncontract import executeContract
    recursiveset = definition.recursiveset["actions"]

    source = definition.recursiveset["source"]
    
    items = outputs.get(source)
    #print(f"RECURSIVE DEBUG DURING {definition.name}")
    #print(items)

    if items is None:
        print(f"No items available in {source} for {definition.name}")
        return outputs, None

    reverse = definition.recursiveset.get("reverse", False)

    if reverse:
        #print("reversing")
        items = reversed(items)

    for item in items:
        outputs[definition.recursiveset["outputlabel"]] = item

        outputs["stopsignals"] = []
        for job in recursiveset:

            stop = checkDependency(job, outputs)

            #print(f"STOP SIGNAL DEBUGGING during {job.name}")
            #print(outputs["stopsignals"])
            #print(stop)

            if stop:
                outputs["processes"][definition.name]["stopsignals"].append(job.alias)
                #print("STOP SIGNAL DETECTED")
                #print(f"Stopping {job.name} due to stop signal")
                continue

            #print(f"RECURSIVE DEBUG DURING {job.name}")
            #print(item)
            #outputs, response = buildAction(job, outputs)
            if job.kind == "action":
                outputs["processes"][definition.name][job.name] = {}
            
            outputs, response = executeContract(job, outputs)
            responses.append(response)
            if job.kind == "action":
                outputs["processes"][definition.name][job.name]["response"] = response

            outputs["processes"][definition.name]["completed"].append(job.alias)
            

    retain = definition.recursiveset.get("retain", True)

    if not retain:
        outputs.pop(source, None)

    outputs.pop("stopsignals", None)

    return outputs, responses