#ifndef VECTOR_H
#define VECTOR_H VECTOR_H

#include <math.h>                   /* sqrt() */

#include <iostream>

class Vector
{
    public:
        Vector()
        {
            m_array[0] = 0.0;
            m_array[1] = 0.0;
            m_array[2] = 0.0;
        }

        Vector(double x, double y, double z)
        {
            m_array[0] = x;
            m_array[1] = y;
            m_array[2] = z;
        }

        Vector & normalize()
        {
            double length = mag();
            m_array[0] /= length;
            m_array[1] /= length;
            m_array[2] /= length;
            return *this;
        }

        double mag() const
        {
            return sqrt(m_array[0] * m_array[0]
                      + m_array[1] * m_array[1]
                      + m_array[2] * m_array[2]);
        }

        double mag2() const
        {
            return m_array[0] * m_array[0]
                 + m_array[1] * m_array[1]
                 + m_array[2] * m_array[2];
        }

        double dist_to(const Vector & other) const
        {
            return (other - *this).mag();
        }

        Vector proj(const Vector & target) const
        {
            Vector target_normalized = target;
            target_normalized.normalize();
            return target_normalized * ((*this) % target_normalized);
        }

        Vector reflect(const Vector & target) const
        {
            Vector projected = proj(target);
            Vector me_to_proj = projected - (*this);
            return (*this) + me_to_proj * 2.0;
        }

        Vector getPerpendicular() const
        {
            Vector t = *this;
            t.normalize();
            Vector p = t * Vector(0, 0, 1);
            if (p.mag() <= 0.1)
            {
                p = t * Vector(1, 0, 0);
            }
            return p;
        }

        Vector mult(const Vector & v2) const
        {
            Vector result;
            result[0] = m_array[0] * v2.m_array[0];
            result[1] = m_array[1] * v2.m_array[1];
            result[2] = m_array[2] * v2.m_array[2];
            return result;
        }

        Vector div(const Vector & v2) const
        {
            Vector result;
            result[0] = m_array[0] / v2.m_array[0];
            result[1] = m_array[1] / v2.m_array[1];
            result[2] = m_array[2] / v2.m_array[2];
            return result;
        }

        Vector operator-() const
        {
            Vector result;
            result[0] = -m_array[0];
            result[1] = -m_array[1];
            result[2] = -m_array[2];
            return result;
        }

        /* Compute the dot-product of two vectors */
        double operator%(const Vector & v2) const
        {
            return m_array[0] * v2.m_array[0]
                + m_array[1] * v2.m_array[1]
                + m_array[2] * v2.m_array[2];
        }

        /* Compute the cross-product of two vectors */
        Vector operator*(const Vector & v2) const
        {
            Vector result;
            result[0] = m_array[1] * v2.m_array[2] - m_array[2] * v2.m_array[1];
            result[1] = m_array[2] * v2.m_array[0] - m_array[0] * v2.m_array[2];
            result[2] = m_array[0] * v2.m_array[1] - m_array[1] * v2.m_array[0];
            return result;
        }

        Vector operator+(const Vector & v2) const
        {
            Vector result;
            result[0] = m_array[0] + v2.m_array[0];
            result[1] = m_array[1] + v2.m_array[1];
            result[2] = m_array[2] + v2.m_array[2];
            return result;
        }

        Vector operator-(const Vector & v2) const
        {
            Vector result;
            result[0] = m_array[0] - v2.m_array[0];
            result[1] = m_array[1] - v2.m_array[1];
            result[2] = m_array[2] - v2.m_array[2];
            return result;
        }

        Vector operator*(double scale) const
        {
            Vector result;
            result[0] = m_array[0] * scale;
            result[1] = m_array[1] * scale;
            result[2] = m_array[2] * scale;
            return result;
        }

        Vector operator/(double scale) const
        {
            Vector result;
            result[0] = m_array[0] / scale;
            result[1] = m_array[0] / scale;
            result[2] = m_array[0] / scale;
            return result;
        }

        Vector & operator+=(const Vector & v2)
        {
            m_array[0] += v2.m_array[0];
            m_array[1] += v2.m_array[1];
            m_array[2] += v2.m_array[2];
            return *this;
        }

        Vector & operator-=(const Vector & v2)
        {
            m_array[0] -= v2.m_array[0];
            m_array[1] -= v2.m_array[1];
            m_array[2] -= v2.m_array[2];
            return *this;
        }

        double & operator[](int idx) { return m_array[idx]; }
        double operator[](int idx) const { return m_array[idx]; }

        static Vector randomVector();

        static const Vector X;
        static const Vector Y;
        static const Vector Z;

    protected:
        double  m_array[3];
};

std::ostream & operator<<(std::ostream & out, const Vector & v);
static inline Vector operator*(double d, const Vector & v) { return v * d; }
static inline Vector operator/(double d, const Vector & v) { return v / d; }

#endif