###
# Modern Albufeira Prolog Interpreter
#
# Warranty & Liability
# To the extent permitted by applicable law and unless explicitly
# otherwise agreed upon, XLOG Technologies AG makes no warranties
# regarding the provided information. XLOG Technologies AG assumes
# no liability that any problems might be solved with the information
# provided by XLOG Technologies AG.
#
# Rights & License
# All industrial property rights regarding the information - copyright
# and patent rights in particular - are the sole property of XLOG
# Technologies AG. If the company was not the originator of some
# excerpts, XLOG Technologies AG has at least obtained the right to
# reproduce, change and translate the information.
#
# Reproduction is restricted to the whole unaltered document. Reproduction
# of the information is only allowed for non-commercial uses. Selling,
# giving away or letting of the execution of the library is prohibited.
# The library can be distributed as part of your applications and libraries
# for execution provided this comment remains unchanged.
#
# Restrictions
# Only to be distributed with programs that add significant and primary
# functionality to the library. Not to be distributed with additional
# software intended to replace any components of the library.
#
# Trademarks
# Jekejeke is a registered trademark of XLOG Technologies AG.
##

from nova.core import (
    set, deref, is_structure, make_check,
    check_integer, MAX_ARITY, check_nil,
    exec_build, exec_unify, int32)


class PiWam:
    def __init__(self):
        self.code = NotImplemented
        self.state = NotImplemented


def run(pi):
    pc = 0
    accu = 0
    while pc < len(pi.code):
        instr = pi.code[pc]
        pc += 1
        value = run_get(pi, instr)
        accu = run_fun(instr, accu, value)
        run_set(pi, instr, accu)
        pc += run_jump(instr, accu)


def run_get(pi, instr):
    act = instr >> 20
    obj = ((instr >> 10) & 0x03FF) - 512
    mode = (act >> 4) & 0x0F
    if mode == 0:  # get
        return pi.state[obj]
    elif mode == 1:  # cst
        return obj
    elif mode == 2:  # set
        return 0
    elif mode == 4:  # out
        return 0
    elif mode == 5:  # in
        return int32(int(input(": ")))
    else:
        raise ValueError("illegal mode")


def run_fun(instr, accu, value):
    act = instr >> 20
    fun = act >> 8
    if fun == 0:  # val
        return value
    elif fun == 1:  # acc
        return accu
    elif fun == 2:  # add
        return int32(value + accu)
    elif fun == 3:  # sub
        return int32(value - accu)
    elif fun == 4:  # mul
        return int32(value * accu)
    elif fun == 8:  # nil
        # t.b.d.
        return 0
    elif fun == 9:  # cons
        # t.b.d.
        return 0
    elif fun == 10:  # car
        # t.b.d.
        return 0
    elif fun == 11:  # cdr
        # t.b.d.
        return 0
    else:
        raise ValueError("illegal fun")


def run_set(pi, instr, accu):
    act = instr >> 20
    obj = ((instr >> 10) & 0x03FF) - 512
    mode = (act >> 4) & 0x0F
    if mode == 0:  # get
        return
    elif mode == 1:  # cst
        return
    elif mode == 2:  # set
        pi.state[obj] = accu
        return
    elif mode == 4:  # out
        print(accu)
        return
    elif mode == 5:  # in
        return
    else:
        raise ValueError("illegal mode")


def run_jump(instr, accu):
    act = instr >> 20
    rel = (instr & 0x03FF) - 512
    cond = act & 0x0F
    if cond == 0:  # eq
        return rel if accu == 0 else 0
    elif cond == 1:  # nq
        return rel if accu != 0 else 0
    elif cond == 2:  # ls
        return rel if accu < 0 else 0
    elif cond == 3:  # gr
        return rel if accu > 0 else 0
    elif cond == 4:  # lq
        return rel if accu <= 0 else 0
    elif cond == 5:  # gq
        return rel if accu >= 0 else 0
    elif cond == 8:  # unit
        # t.b.d.
        return 0
    elif cond == 9:  # pair
        # t.b.d.
        return 0
    elif cond == 15:  # true
        return rel
    else:
        raise ValueError("illegal cond")


#################################################################
# π-WAM Interface                                               #
#################################################################

###
# test_ir_piwam_new(C, S, P): internal only
# The predicate succeeds in P with a CPU backed π-WAM for
# the code C and the state S.
##
def test_ir_piwam_new(args):
    pi = PiWam()
    alpha = exec_build(args[0])
    pi.code = list_ints(alpha)
    beta = exec_build(args[1])
    pi.state = list_ints(beta)
    return exec_unify(args[2], pi)


def list_ints(obj):
    peek = obj
    i = 0
    while (is_structure(peek) and
           peek.functor == "." and
           len(peek.args) == 2 and
           i < MAX_ARITY):
        i += 1
        peek = deref(peek.args[1])
    check_nil(peek)
    args = [NotImplemented] * i
    peek = obj
    i = 0
    while (is_structure(peek) and
           peek.functor == "." and
           len(peek.args) == 2):
        val = deref(peek.args[0])
        check_integer(val)
        val &= 0xFFFFFFFF
        if val >= 0x80000000:
            val -= 0x100000000
        args[i] = val
        i += 1
        peek = deref(peek.args[1])
    return args


###
# test_ir_piwam_run(P): internal only
# The predicate fails. As a side effect it will run the
# π-WAM P in the current thread. The predicate terminates
# when the π-WAM P terminates.
##
def test_ir_piwam_run(args):
    alpha = exec_build(args[0])
    run(alpha)
    return False


#################################################################
# π-WAM Lib Init                                                #
#################################################################

def main():
    set("ir_piwam_new", 3, make_check(test_ir_piwam_new))
    set("ir_piwam_run", 1, make_check(test_ir_piwam_run))