#include "vector.h"
#include <math.h>

Vector::Vector() { dx = dy = dz = 0.0f; }

Vector::Vector(float v_dx, float v_dy, float v_dz) {
  dx = v_dx;
  dy = v_dy;
  dz = v_dz;
}

Vector::~Vector() {}

float Vector::operator[](int i) const {
  switch (i) {
  case 0:
    return dx; // dx is equivalent to index 0
  case 1:
    return dy; // dy is equivalent to index 1
  case 2:
    return dz; // dz is equivalent to index 2
  default:
    std::cout << "Error: . . . .";
    return dx;
  }
}

float Vector::norm() const {
    float x_squared = dx*dx;
    float y_squared = dy*dy;
    float z_squared = dz*dz;
    return sqrt(x_squared+y_squared+z_squared);
}

const Vector Vector::normalised() const {
  float vector_norm = this->norm();

  return Vector(dx/vector_norm, dy/vector_norm, dz/vector_norm);
}

float Vector::dot(const Vector &v) const { //dot product
  return dx*v.dx + dy*v.dy + dz*v.dz;
}

const Vector Vector::cross(const Vector &v) const {
  //a2b3-a3b1
  float x_cross = dy*v.dz-dz*v.dy;
  //a3b1-a1b3
  float y_cross = dz*v.dx-dx*v.dz;
  //a1b2-a2b1
  float z_cross = dx*v.dy-dy*v.dx;

  return Vector(x_cross, y_cross, z_cross);
}

// C++ print routine
std::ostream &operator<<(std::ostream &ostr, Vector v) {
  ostr << "[" << v.dx << ", " << v.dy << ", " << v.dz << "]";
  return ostr;
}

// Unary Minuse
const Vector operator-(const Vector &v) {
  return Vector(-v.dx, -v.dy, -v.dz);
}

// Addition
const Point operator+(const Point &p, const Vector &v) {
  return Point(p.x+v.dx, p.y+v.dy, p.z+v.dz);
}

const Vector operator+(const Vector &v, const Vector &w) {
  return Vector(v.dx+w.dx, v.dy+w.dy, v.dz+w.dz);
}

// Subtraction
const Point operator-(Point p, Vector v) {
    return Point(p.x-v.dx, p.y-v.dy, p.z-v.dz);
}

const Vector operator-(Vector v, Vector w) {
   return Vector(v.dx-w.dx, v.dy-w.dy, v.dz-w.dz);
}

const Vector operator-(const Point &tail, const Point &head) {
  return Vector(head.x-tail.x, head.y-tail.y, head.z-tail.z);
}

// Scalar Multiplication
const Vector operator*(float s, const Vector &v) {
  return Vector(s*v.dx, s*v.dy, s*v.dz);
}

const Vector operator*(const Vector &v, float s) {
  return Vector(v.dx*s, v.dy*s, v.dz*s);
}