#ifndef NODES_H
#define NODES_H NODES_H

#include <stdlib.h>                 /* exit() */

#include <vector>
#include <string>
#include <iostream>

#include "util/refptr.h"
#include "util/Vector.h"
#include "util/Scope.h"

extern refptr<Scope> parser_scope;

class Node
{
    public:
        virtual ~Node();
        void addChild(refptr<Node> child) { m_children.push_back(child); }
        void addChildren(refptr<Node> other);
        std::vector< refptr<Node> > & getChildren() { return m_children; }

        virtual int getInteger() { return getNumber(); }

        virtual double getNumber()
        {
            std::cerr << "Warning: Node::getNumber() called!" << std::endl;
            return 0.0;
        }
        virtual refptr<Vector> getVector()
        {
            std::cerr << "Warning: Node::getVector() called!" << std::endl;
            return refptr<Vector>(NULL);
        }
        virtual std::string getString()
        {
            std::cerr << "Warning: Node::getString() called!" << std::endl;
            return "";
        }
        virtual refptr<Node> getNode(int idx)
        {
            std::cerr << "Warning: Node::getNode() called!" << std::endl;
            return NULL;
        }
        virtual refptr<Node> evaluate()
        {
            std::cerr << "Warning: Node::evaluate() called!" << std::endl;
            return NULL;
        }
        virtual void 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() )
                {
                    (*it)->evaluateChildren(evaluated);
                    parent->addChild(evaluated);
                }
            }
        }

        virtual bool isShape() { return false; }
        virtual bool isMaterial() { return false; }
        virtual bool isTransformBlock() { return false; }
        virtual bool isExpression() { return false; }

    protected:
        std::vector< refptr<Node> > m_children;
};

typedef refptr<Node> NodeRef;


class NumberNode : public Node
{
    public:
        NumberNode(double number)
        {
            m_number = number;
        }
        NumberNode(NodeRef expr)
        {
            m_expr = expr;
        }
        virtual double getNumber()
        {
            return m_number;
        }
        virtual refptr<Node> evaluate()
        {
            return new NumberNode(m_number);
        }

    protected:
        double m_number;
        NodeRef m_expr;
};

class VectorNode : public Node
{
    public:
        VectorNode(NodeRef a, NodeRef b, NodeRef c)
            : m_a(a), m_b(b), m_c(c), m_direct(true)
        {
        }
        VectorNode(NodeRef node)
            : m_vector(node), m_direct(false)
        {
        }
        refptr<Vector> getVector()
        {
            return m_direct
                ? new Vector(m_a->getNumber(),
                        m_b->getNumber(),
                        m_c->getNumber())
                : m_a->getVector();
        }
        virtual NodeRef evaluate()
        {
            return m_direct
                ? new VectorNode(m_a->evaluate(),
                        m_b->evaluate(),
                        m_c->evaluate())
                : m_a->evaluate();
        }
    protected:
        NodeRef m_a, m_b, m_c, m_vector;
        bool m_direct;
};


class AmbientNode : public VectorNode
{
    public:
        AmbientNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new AmbientNode(m_vector->evaluate());
        }
};

class AmbientOcclusionNode : public NumberNode
{
    public:
        AmbientOcclusionNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new AmbientOcclusionNode(m_expr->evaluate());
        }
};

class BoxNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate()
        {
            return new BoxNode();
        }
};

class CameraNode : public Node
{
    public:
        virtual NodeRef evaluate()
        {
            return new CameraNode();
        }
};

class ColorNode : public VectorNode
{
    public:
        ColorNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new ColorNode(m_vector->evaluate());
        }
};

class CylNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate()
        {
            return new CylNode();
        }
};

class DiffuseNode : public VectorNode
{
    public:
        DiffuseNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new DiffuseNode(m_vector->evaluate());
        }
};

class ExposureNode : public NumberNode
{
    public:
        ExposureNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new ExposureNode(m_expr->evaluate());
        }
};

class ExtrudeNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate()
        {
            return new ExtrudeNode();
        }
};

class HeightNode : public NumberNode
{
    public:
        HeightNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new HeightNode(m_expr->evaluate());
        }
};

class IdentifierNode : public Node
{
    public:
        IdentifierNode(const std::string & str) { m_string = str; }
        std::string getString() { return m_string; }
        virtual NodeRef evaluate()
        {
            return new IdentifierNode(m_string);
        }
    protected:
        std::string m_string;
};

class IntersectNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate()
        {
            return new IntersectNode();
        }
};

class ItemsNode : public Node
{
    public:
        virtual NodeRef evaluate()
        {
            return new ItemsNode();
        }
};

class JitterNode : public NumberNode
{
    public:
        JitterNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new JitterNode(m_expr->evaluate());
        }
};

class LightNode : public Node
{
    public:
        virtual NodeRef evaluate() { return new LightNode(); }
};

class LookAtNode : public VectorNode
{
    public:
        LookAtNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new LookAtNode(m_vector->evaluate());
        }
};

class MaterialNode : public Node
{
    public:
        bool isMaterial() { return true; }
        virtual NodeRef evaluate() { return new MaterialNode(); }
};

class MaterialDefinitionNode : public IdentifierNode
{
    public:
        MaterialDefinitionNode(const std::string & str) : IdentifierNode(str) {}
        virtual NodeRef evaluate()
        {
            return new MaterialDefinitionNode(m_string);
        }
};

class MaterialRefNode : public IdentifierNode
{
    public:
        MaterialRefNode(const std::string & str) : IdentifierNode(str) {}
        bool isMaterial() { return true; }
        virtual NodeRef evaluate() { return new MaterialRefNode(m_string); }
};

class MaxDepthNode : public NumberNode
{
    public:
        MaxDepthNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new MaxDepthNode(m_expr->evaluate());
        }
};

class MultisampleNode : public NumberNode
{
    public:
        MultisampleNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new MultisampleNode(m_expr->evaluate());
        }
};

class NGonNode : public NumberNode
{
    public:
        NGonNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new NGonNode(m_expr->evaluate());
        }
};

class OffsetNode : public NumberNode
{
    public:
        OffsetNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new OffsetNode(m_expr->evaluate());
        }
};

class OptionsNode : public Node
{
    public:
        virtual NodeRef evaluate() { return new OptionsNode(); }
};

class PlaneNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate() { return new PlaneNode(); }
};

class PlanePositionNode : public VectorNode
{
    public:
        PlanePositionNode(NodeRef vec_node, NodeRef dist)
            : VectorNode(vec_node)
        {
            m_dist = dist;
        }
        double getNumber() { return m_dist->getNumber(); }
        virtual NodeRef evaluate()
        {
            return new PlanePositionNode(m_vector->evaluate(),
                    m_dist->evaluate());
        }

    protected:
        NodeRef m_dist;
};

class PolygonNode : public Node
{
    public:
        virtual NodeRef evaluate() { return new PolygonNode(); }
};

class PositionNode : public VectorNode
{
    public:
        PositionNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new PositionNode(m_vector->evaluate());
        }
};

class RadiusNode : public NumberNode
{
    public:
        RadiusNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new RadiusNode(m_expr->evaluate());
        }
};

class ReflectanceNode : public NumberNode
{
    public:
        ReflectanceNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new ReflectanceNode(m_expr->evaluate());
        }
};

class RotateNode : public VectorNode
{
    public:
        RotateNode(NodeRef angle, NodeRef vec_node)
            : VectorNode(vec_node)
        {
            m_angle = angle;
        }
        double getNumber() { return m_angle->getNumber(); }
        virtual NodeRef evaluate()
        {
            return new RotateNode(m_angle->evaluate(), m_vector->evaluate());
        }

    protected:
        NodeRef m_angle;
};

class RotateBlockNode : public RotateNode
{
    public:
        RotateBlockNode(NodeRef angle, NodeRef vec_node)
            : RotateNode(angle, vec_node) {}
        bool isTransformBlock() { return true; }
        virtual NodeRef evaluate()
        {
            return new RotateBlockNode(m_angle->evaluate(), m_vector->evaluate());
        }
};

class ScaleNode : public VectorNode
{
    public:
        ScaleNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new ScaleNode(m_vector->evaluate());
        }
};

class ScaleBlockNode : public ScaleNode
{
    public:
        ScaleBlockNode(NodeRef vector) : ScaleNode(vector) {}
        bool isTransformBlock() { return true; }
        virtual NodeRef evaluate()
        {
            return new ScaleBlockNode(m_vector->evaluate());
        }
};

class ScaleScalarNode : public Node
{
    public:
        ScaleScalarNode(NodeRef expr)
            : m_expr(expr)
        {
        }
        virtual NodeRef evaluate()
        {
            NodeRef n = m_expr->evaluate();
            return new VectorNode(n, n, n);
        }
    protected:
        NodeRef m_expr;
};

class SceneNode : public Node
{
    public:
        virtual NodeRef evaluate() { return new SceneNode(); }
};

class ShapeDefinitionNode : public IdentifierNode
{
    public:
        ShapeDefinitionNode(const std::string & str) : IdentifierNode(str) {}
        virtual NodeRef evaluate() { return new ShapeDefinitionNode(m_string); }
};

class ShapeRefNode : public IdentifierNode
{
    public:
        ShapeRefNode(const std::string & str) : IdentifierNode(str) {}
        bool isShape() { return true; }
        virtual NodeRef evaluate() { return new ShapeRefNode(m_string); }
};

class ShininessNode : public NumberNode
{
    public:
        ShininessNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new ShininessNode(m_expr->evaluate());
        }
};

class SizeNode : public VectorNode
{
    public:
        SizeNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new SizeNode(m_vector->evaluate());
        }
};

class SpecularNode : public VectorNode
{
    public:
        SpecularNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new SpecularNode(m_vector->evaluate());
        }
};

class SphereNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate() { return new SphereNode(); }
};

class SubtractNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate() { return new SubtractNode(); }
};

class TranslateNode : public VectorNode
{
    public:
        TranslateNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new TranslateNode(m_vector->evaluate());
        }
};

class TranslateBlockNode : public TranslateNode
{
    public:
        TranslateBlockNode(NodeRef vector) : TranslateNode(vector) {}
        bool isTransformBlock() { return true; }
        virtual NodeRef evaluate()
        {
            return new TranslateBlockNode(m_vector->evaluate());
        }
};

class TransparencyNode : public NumberNode
{
    public:
        TransparencyNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new TransparencyNode(m_expr->evaluate());
        }
};

class UnionNode : public Node
{
    public:
        bool isShape() { return true; }
        virtual NodeRef evaluate() { return new UnionNode(); }
};

class UpNode : public VectorNode
{
    public:
        UpNode(NodeRef vector) : VectorNode(vector) {}
        virtual NodeRef evaluate()
        {
            return new UpNode(m_vector->evaluate());
        }
};

class VFOVNode : public NumberNode
{
    public:
        VFOVNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new VFOVNode(m_expr->evaluate());
        }
};

class WidthNode : public NumberNode
{
    public:
        WidthNode(NodeRef e) : NumberNode(e) {}
        virtual NodeRef evaluate()
        {
            return new WidthNode(m_expr->evaluate());
        }
};

/******** scripting nodes ********/

class ExpressionNode : public Node
{
    public:
        bool isExpression() { return true; }
        virtual double getNumber() = 0;
};

class AssignmentNode : public ExpressionNode
{
    public:
        AssignmentNode(NodeRef varref, NodeRef expr)
            : m_varref(varref), m_expr(expr)
        {
        }
        std::string getString() { return m_varref->getString(); }
        double getNumber()
        {
            double n = m_expr->getNumber();
            parser_scope->putGlobal(getString(), n);
            return n;
        }
    protected:
        NodeRef m_varref;
        NodeRef m_expr;
};

class LocalAssignmentNode : public ExpressionNode
{
    public:
        LocalAssignmentNode(NodeRef varref, NodeRef expr)
            : m_varref(varref), m_expr(expr)
        {
        }
        std::string getString() { return m_varref->getString(); }
        double getNumber()
        {
            double n = m_expr->getNumber();
            parser_scope->putLocal(getString(), n);
            return n;
        }
    protected:
        NodeRef m_varref;
        NodeRef m_expr;
};

class LocalDeclNode : public ExpressionNode
{
    public:
        LocalDeclNode(NodeRef varref) : m_varref(varref) { }
        double getNumber()
        {
            parser_scope->putLocal(m_varref->getString(), 0.0);
            return 0.0;
        }
    protected:
        NodeRef m_varref;
};

class BinOpNode : public ExpressionNode
{
    public:
        BinOpNode(char op, NodeRef one, NodeRef two)
            : m_op(op), one(one), two(two)
        {
        }
        virtual double getNumber();
    protected:
        char m_op;
        NodeRef one;
        NodeRef two;
};

class BoolExpressionNode : public Node
{
    public:
        BoolExpressionNode(char op, NodeRef one, NodeRef two)
            : m_op(op), one(one), two(two)
        {
        }
        int getInteger();
    protected:
        char m_op;
        NodeRef one;
        NodeRef two;
};

class VarRefNode : public Node
{
    public:
        VarRefNode(const std::string & str) { m_string = str; }
        std::string getString() { return m_string; }
        double getNumber()
        {
            if (parser_scope->contains(m_string))
            {
                return parser_scope->get(m_string);
            }
            std::cerr << "Error: No identifier '" << m_string << "' in scope"
                << std::endl;
            exit(4);
        }
    protected:
        std::string m_string;
};

class ForNode : public Node
{
    public:
        ForNode(NodeRef e1, NodeRef e2, NodeRef e3)
        {
            m_nodes[0] = e1;
            m_nodes[1] = e2;
            m_nodes[2] = e3;
        }
        NodeRef getNode(int idx)
        {
            if (0 <= idx && idx <= 2)
            {
                return m_nodes[idx];
            }
            return NULL;
        }
    protected:
        NodeRef m_nodes[3];
};

#endif