#ifndef NODES_H
#define NODES_H NODES_H

#include "util/refptr.h"
#include "util/Vector.h"
#include <vector>

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 0; }
        virtual double getNumber() { return 0.0; }
        virtual refptr<Vector> getVector()
        {
            return refptr<Vector>(NULL);
        }
        virtual bool isShape() { return false; }

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


class IntegerNode : public Node
{
    public:
        IntegerNode(int number) { m_number = number; }
        int getInteger() { return m_number; }
        double getNumber() { return m_number; }

    protected:
        int m_number;
};

class NumberNode : public Node
{
    public:
        NumberNode(double number) { m_number = number; }
        double getNumber() { return m_number; }

    protected:
        double m_number;
};

class VectorNode : public Node
{
    public:
        VectorNode(refptr<Vector> vector) { m_vector = vector; }
        refptr<Vector> getVector() { return m_vector; }

    protected:
        refptr<Vector> m_vector;
};


class AmbientNode : public VectorNode
{
    public:
        AmbientNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class BoxNode : public Node
{
    public:
        bool isShape() { return true; }
};

class CameraNode : public Node
{
};

class ColorNode : public VectorNode
{
    public:
        ColorNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class CylNode : public Node
{
    public:
        bool isShape() { return true; }
};

class DiffuseNode : public VectorNode
{
    public:
        DiffuseNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class HeightNode : public IntegerNode
{
    public:
        HeightNode(int i) : IntegerNode(i) {}
};

class IntersectNode : public Node
{
    public:
        bool isShape() { return true; }
};

class ItemsNode : public Node
{
};

class LightNode : public Node
{
};

class LookAtNode : public VectorNode
{
    public:
        LookAtNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class MaterialNode : public Node
{
};

class MultisampleNode : public IntegerNode
{
    public:
        MultisampleNode(int i) : IntegerNode(i) {}
};

class OptionsNode : public Node
{
};

class PlaneNode : public Node
{
    public:
        bool isShape() { return true; }
};

class PlanePositionNode : public Node
{
    public:
        PlanePositionNode(refptr<Vector> vec, double dist)
        {
            m_vector = vec;
            m_dist = dist;
        }
        refptr<Vector> getVector() { return m_vector; }
        double getNumber() { return m_dist; }

    protected:
        refptr<Vector> m_vector;
        double m_dist;
};

class PositionNode : public VectorNode
{
    public:
        PositionNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class RadiusNode : public NumberNode
{
    public:
        RadiusNode(double d) : NumberNode(d) {}
};

class ReflectanceNode : public NumberNode
{
    public:
        ReflectanceNode(double d) : NumberNode(d) {}
};

class RotateNode : public VectorNode
{
    public:
        RotateNode(double angle, refptr<Vector> vector)
            : VectorNode(vector)
        {
            m_angle = angle;
        }
        double getNumber() { return m_angle; }

    protected:
        double m_angle;
};

class RotateBlockNode : public RotateNode
{
    public:
        RotateBlockNode(double angle, refptr<Vector> vector)
            : RotateNode(angle, vector)
        {
        }
};

class ScaleNode : public VectorNode
{
    public:
        ScaleNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class ScaleBlockNode : public ScaleNode
{
    public:
        ScaleBlockNode(refptr<Vector> vector) : ScaleNode(vector) {}
};

class SceneNode : public Node
{
};

class ShininessNode : public NumberNode
{
    public:
        ShininessNode(double d) : NumberNode(d) {}
};

class SizeNode : public VectorNode
{
    public:
        SizeNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class SpecularNode : public VectorNode
{
    public:
        SpecularNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class SphereNode : public Node
{
    public:
        bool isShape() { return true; }
};

class SubtractNode : public Node
{
    public:
        bool isShape() { return true; }
};

class TranslateNode : public VectorNode
{
    public:
        TranslateNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class TranslateBlockNode : public TranslateNode
{
    public:
        TranslateBlockNode(refptr<Vector> vector) : TranslateNode(vector) {}
};

class UnionNode : public Node
{
    public:
        bool isShape() { return true; }
};

class UpNode : public VectorNode
{
    public:
        UpNode(refptr<Vector> vector) : VectorNode(vector) {}
};

class VFOVNode : public NumberNode
{
    public:
        VFOVNode(double d) : NumberNode(d) {}
};

class WidthNode : public IntegerNode
{
    public:
        WidthNode(int i) : IntegerNode(i) {}
};

#endif