#!/usr/bin/env python3

import pyactr as actr
import prod_addition
import prod_comp
import prod_multi
import prod_numbers
import prod_procedure
import prod_motor
import model_env


# https://stackoverflow.com/a/39644726
def get_digit(number, n):
    return number // 10**n % 10


def init():
    env = actr.Environment()
    Model = actr.ACTRModel(environment=env)

    DM = Model.decmem
    goal = Model.goal
    imaginal = Model.set_goal(name="imaginal", delay=0.2)

    actr.chunktype("number", ("number", "next", "ones", "tens", "hundreds"))
    actr.chunktype(
        "procedure",
        (
            "proc",
            "op1",
            "arg1_1",
            "arg1_2",
            "op2",
            "arg2_1",
            "arg2_2",
        ),
    )
    actr.chunktype(
        "math_goal",
        (
            "task",
            "result1",
            "result2",
            "op",
            "nextop",
            "arg1",
            "arg2",
            "result",
            "expand_slot",
            "hundreds1",
            "tens1",
            "ones1",
            "hundreds2",
            "tens2",
            "ones2",
            "hundreds_ans",
            "tens_ans",
            "ones_ans",
            "mul_counter",
            "ones_carry",
            "tens_carry",
        ),
    )
    actr.chunktype(
        "math_op",
        (
            "op",
            "arg1",
            "arg2",
            "result",
        ),
    )

    # Add procedures
    DM.add(
        actr.makechunk(
            "procedure1",
            "procedure",
            proc="proc1",
            op1="add",
            arg1_1=99,
            arg1_2=211,
            op2="greater",
            arg2_1=10,
            arg2_2=2,
        )
    )

    # Add numbers 0-999 to decmem
    for i in range(0, 1000):
        DM.add(
            actr.makechunk(
                f"number{str(i)}",
                "number",
                number=i,
                next=i + 1,
                ones=get_digit(i, 0),
                tens=get_digit(i, 1),
                hundreds=get_digit(i, 2),
            )
        )

    # Add comparison relations to single digit numbers
    for i in range(0, 11):
        for j in range(0, 11):
            DM.add(
                actr.makechunk(
                    f"greater{i}{j}",
                    "math_op",
                    op="greater",
                    arg1=i,
                    arg2=j,
                    result=max(i, j),
                )
            )
            # DM.add(
            #     actr.makechunk(
            #         f"lesser{i}{j}",
            #         "math_op",
            #         op="lesser",
            #         arg1=i,
            #         arg2=j,
            #         result=min(i, j),
            #     )
            # )
            DM.add(
                actr.makechunk(
                    f"plus{i}{j}", "math_op", op="add", arg1=i, arg2=j, result=i + j
                )
            )
    return Model, DM, goal, imaginal, env


def add_goal(goal, op, arg1, arg2):

    goal.add(actr.makechunk("", "math_goal", op=op, task=op, arg1=arg1, arg2=arg2))
    # imaginal.add(
    #     actr.makechunk(
    #         "",
    #         "math_op",
    #         op=op,
    #         arg1=arg1,
    #         arg2=arg2,
    #         ones1=get_digit(arg1, 0),
    #         tens1=get_digit(arg1, 1),
    #         hundreds1=get_digit(arg1, 2),
    #         ones2=get_digit(arg2, 0),
    #         tens2=get_digit(arg2, 1),
    #         hundreds2=get_digit(arg2, 2),
    #     )
    # )


def general_prod(Model):

    Model.productionstring(
        name="continue_with_next_op",
        string="""
            =g>
            isa     math_goal
            op      done
            nextop  ~None
            nextop  =nextop
            ==>
            =g>
            isa     math_goal
            op      =nextop
        """,
    )


def wait_input():
    op = input("op\n")
    arg1 = input("arg1\n")
    arg2 = input("arg2\n")
    return op, int(arg1), int(arg2)


def add_proc(goal, proc):
    input()
    goal.add(actr.makechunk("", "math_goal", proc=proc, ones_carry="hello"))


def start():
    while True:
        # op, arg1, arg2 = wait_input()
        Model, DM, goal, imaginal, env = init()
        # add_goal(goal, op, arg1, arg2)
        add_proc(goal, "proc1")
        envs = model_env.get_env()

        general_prod(Model)
        prod_procedure.procedures(Model)
        number_prods = prod_numbers.number(Model)
        add_prods = prod_addition.addition(Model)
        greater_prods = prod_comp.greater_than(Model)
        less_prods = prod_comp.less_than(Model)
        multi_prods = prod_multi.multiplication(Model)
        motor_prods = prod_motor.procedures(Model)

        # for prod in multi_prods:
        #     print(prod)
        #     print("\n")

        print("goal: ", goal)
        # print("imaginal: ", imaginal)
        sim = Model.simulation(
            gui=False,
            environment_process=env.environment_process,
            stimuli=envs,
            triggers="space",
        )
        while True:
            sim.step()
            if sim.current_event.action == "KEY PRESSED: SPACE":
                break
        # x.run(max_time=8)
        print("Simulation time: ", sim.show_time())
        print("goal: ", goal)
        print(list(env))
        # print("imaginal: ", imaginal)
        # imaginal.show("hundreds_ans")
        # imaginal.show("tens_ans")
        # imaginal.show("ones_ans")
        # result_ones = str(getattr(imaginal._data.copy().pop(), "ones_ans"))
        # result_tens = str(getattr(imaginal._data.copy().pop(), "tens_ans"))
        # result_huns = str(getattr(imaginal._data.copy().pop(), "hundreds_ans"))

        # result_num = result_huns + result_tens + result_ones
        # print(result_num)
        # print(list(DM))
        # numbers = [
        #     x for x in list(DM) if x.typename != "number" and x.typename != "math_op"
        # ]
        # numbers = [
        #     x for x in list(DM) if x.typename != "number" and x.typename == "math_op"
        # ]
        # print(numbers)
        math_goals = [sim for sim in list(DM) if sim.typename == "procedure"]
        print(math_goals)


if __name__ == "__main__":
    start()