package net.ciklum.icfpc11.plan

import net.ciklum.icfpc11.domain.Card
import net.ciklum.icfpc11.plan.MovePlanner.BinaryTree
import net.ciklum.icfpc11.plan.ConstantPlanner.Constant
import net.ciklum.icfpc11.plan.ConstantPlanner.Operation

/**
 * helper to construct complex formulas as binary trees
 * @author mym
 */
@Typed
final class FunctionTreeBuilder {
    
    /** cc for constructor */
    private static final BinaryTree cc(Card me) { new BinaryTree(me, [])}
    private static final BinaryTree cc(Card me, BinaryTree... arg) { new BinaryTree(me, (List)arg.collect {it.clone()})}

    static final BinaryTree zero = cc(Card.zero)
    
    static final BinaryTree I = cc(Card.I)
    static final BinaryTree I(BinaryTree sub) {cc(Card.I, sub)}

    static final BinaryTree succ = cc(Card.succ)
    static final BinaryTree succ(BinaryTree sub) {cc(Card.succ, sub)}
    static final BinaryTree dbl = cc(Card.dbl)
    static final BinaryTree dbl(BinaryTree sub) {cc(Card.dbl, sub)}

    static final BinaryTree get = cc(Card.get)
    static final BinaryTree get(BinaryTree sub) {cc(Card.get, sub)}
    static final BinaryTree put = cc(Card.put)
    static final BinaryTree put(BinaryTree sub) {cc(Card.put, sub)}

    static final BinaryTree S = cc(Card.S)
    static final BinaryTree S(BinaryTree... sub) {cc(Card.S, sub)}

    static final BinaryTree K = cc(Card.K)
    static final BinaryTree K(BinaryTree... sub) {cc(Card.K, sub)}

    static final BinaryTree inc = cc(Card.inc)
    static final BinaryTree inc(BinaryTree sub) {cc(Card.inc, sub)}
    static final BinaryTree dec = cc(Card.dec)
    static final BinaryTree dec(BinaryTree sub) {cc(Card.dec, sub)}

    static final BinaryTree attack = cc(Card.attack)
    static final BinaryTree attack(BinaryTree... sub) {cc(Card.attack, sub)}

    static final BinaryTree help = cc(Card.help)
    static final BinaryTree help(BinaryTree... sub) {cc(Card.help, sub)}

    static final BinaryTree zombie = cc(Card.zombie)
    static final BinaryTree zombie(BinaryTree... sub) {cc(Card.zombie, sub)}

    /** constant-to-tree algoritm. you may probably wish to use get(0) to get complex constants from the pool */
    static BinaryTree n(int n) {
        def cards = (List<Card>) new ConstantPlanner().findPath(n).collect {Constant c ->
            c.obtainedBy == Operation.ZERO ? Card.zero : c.obtainedBy == Operation.DBL ? Card.dbl : Card.succ
        }
        def tree = new BinaryTree(cards[0], [])
        for (int i = 1; i < cards.size(); i++) {
            tree = new BinaryTree(cards[i], [tree])
        }
        return tree
    }


}