#include <stdlib.h>

#include <vector>
#include <iostream>
#include <typeinfo>

#include "nodes.h"

using namespace std;

void Node::evaluateChildren(refptr<Node> parent)
{
    /* recursively evaluate all children nodes */
    for (std::vector< refptr<Node> >::iterator it = m_children.begin();
         it != m_children.end();
         it++)
    {
        refptr<Node> evaluated = (*it)->evaluate();
        if ( ! evaluated.isNull() )
        {
            if (typeid(*evaluated) == typeid(EvaluatePropagateNode))
            {
                for (vector<NodeRef>::iterator it2
                        = evaluated->getChildren().begin();
                     it2 != evaluated->getChildren().end();
                     it2++)
                {
                    parent->addChild(*it2);
                }
            }
            else
            {
                (*it)->evaluateChildren(evaluated);
                parent->addChild(evaluated);
            }
        }
    }
}

void Node::addChildren(NodeRef other)
{
    if (other.isNull())
        return;

    for (vector<NodeRef>::const_iterator it = other->m_children.begin();
         it != other->m_children.end();
         it++)
    {
        addChild(*it);
    }
}

Node::~Node()
{
}

NodeRef BinOpNode::evaluate()
{
    double o = one->evaluate()->getNumber();
    double t = two->evaluate()->getNumber();
    double r = 0.0;
    switch (m_op)
    {
        case '*':
            r = o * t;
            break;
        case '/':
            r = o / t;
            break;
        case '+':
            r = o + t;
            break;
        case '-':
            r = o - t;
            break;
        default:
            cerr << "Error: BinOpNode created with op '" << m_op << "'" << endl;
            exit(-3);
    }
    return new NumberNode(r);
}

NodeRef BoolExpressionNode::evaluate()
{
    double o, t;
    double r = 0;
    if (m_op != '!')
    {
        o = one->evaluate()->getNumber();
        t = two->evaluate()->getNumber();
    }
    switch (m_op)
    {
        case '<':
            r = o < t ? 0 : 1;
            break;
        case '>':
            r = o > t ? 0 : 1;
            break;
        case '=':
            r = o == t ? 0 : 1;
            break;
        case 'n':
            r = o != t ? 0 : 1;
            break;
        case '!':
            r = ! one->evaluate()->getInteger();
            break;
        case 'T':
            r = 1;
            break;
    }
    return new NumberNode(r);
}

NodeRef ForNode::evaluate()
{
    NodeRef eval = new EvaluatePropagateNode();

    if (!m_nodes[0].isNull())
    {
        m_nodes[0]->evaluate();
    }

    while (m_nodes[1]->evaluate()->getInteger() != 0)
    {
        for (vector<NodeRef>::iterator it = m_children.begin();
                it != m_children.end();
                it++)
        {
            NodeRef n = (*it)->evaluate();
            if ( ! n.isNull() )
            {
                if (typeid(*n) == typeid(EvaluatePropagateNode))
                {
                    for (vector<NodeRef>::iterator it2 = n->getChildren().begin();
                            it2 != n->getChildren().end();
                            it2++)
                    {
                        eval->addChild(*it2);
                    }
                }
                else
                {
                    eval->addChild(n);
                }
            }
        }

        if (!m_nodes[2].isNull())
        {
            m_nodes[2]->evaluate();
        }
    }

    /* clear out all child nodes so that evaluateChildren() doesn't
     * attempt to evaluate them */
    m_children.clear();

    return eval;
}