#ifndef TRANSFORM_H
#define TRANSFORM_H TRANSFORM_H

#include "refptr.h"
#include "Matrix.h"
#include "Ray.h"
#include "Vector.h"
#include <stack>

class Transform
{
    public:
        Transform getInverse()
        {
            Transform inv;
            inv.m_matrix = m_matrix.getInverse();
            return inv;
        }

        void lookAt(const Vector & eye,
                    const Vector & focus,
                    const Vector & up);
        void translate(double x, double y, double z);
        void translate(refptr<Vector> vec)
        {
            translate((*vec)[0], (*vec)[1], (*vec)[2]);
        }
        void rotate(double angle, double xv, double yv, double zv);
        void rotate(double angle, refptr<Vector> vec)
        {
            rotate(angle, (*vec)[0], (*vec)[1], (*vec)[2]);
        }
        void scale(double xs, double ys, double zs);
        void scale(refptr<Vector> vec)
        {
            scale((*vec)[0], (*vec)[1], (*vec)[2]);
        }
        Matrix & getMatrix() { return m_matrix; }
        Vector transform_point(const Vector & v)
        {
            return m_matrix * v;
        }

        Vector transform_direction(const Vector & v)
        {
            return m_matrix % v;
        }

        Vector transform_normal(const Vector & v)
        {
            return (m_matrix % v).normalize();
        }

        Ray transform_ray(const Ray & r)
        {
            return Ray(m_matrix * r.getOrigin(), m_matrix % r.getDirection());
        }

        Transform operator*(const Transform & other) const
        {
            Transform t;
            t.m_matrix = m_matrix * other.m_matrix;
            return t;
        }

    protected:
        Matrix m_matrix;
};

#endif