#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2015 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_GEOMETRY_MATRIX44_H
#define NUCLEX_GEOMETRY_MATRIX44_H

#include "Nuclex/Geometry/Config.h"
#include "Nuclex/Geometry/Math.h"
#include "Nuclex/Geometry/Point3.h"
#include "Nuclex/Geometry/Vector3.h"
#include "Nuclex/Geometry/Vector4.h"
#include "Nuclex/Geometry/Areas/Rectangle2.h"

#include <cassert>

namespace Nuclex { namespace Geometry {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Matrix that holds an orientation and translation in 4D space</summary>
  /// <remarks>
  ///   This kind of matrix is typically used to store an object's position, scale
  ///   and orientation in 3D space (leaving the 4th dimension, aka W coordinates
  ///   unused and set to the identity matrix values).
  /// </remarks>
  template <typename TScalar>
  struct Matrix44 {

    /// <summary>Number of rows in this matrix</summary>
    public: static const std::size_t RowCount = 4;
    /// <summary>Number of columns in this matrix</summary>
    public: static const std::size_t ColumnCount = 4;

    #pragma region class MatrixRowAccessor

    /// <summary>Accesses a single row in a matrix</summary>
    public: class MatrixRowAccessor {

      /// <summary>Initializes a new matrix row accessor</summary>
      /// <param name="matrix">Matrix that the row accessor will access</param>
      /// <param name="rowIndex">Index of the row the row accessor will access</param>
      public: MatrixRowAccessor(Matrix44 &matrix, std::size_t rowIndex) :
        matrix(matrix),
        rowIndex(rowIndex) {
        if(rowIndex >= 4) {
          throw std::out_of_range("Invalid row index");
        }
      }

      /// <summary>Accesses an entire row of the matrix as a 4D vector</summary>
      public: operator const Vector4<TScalar>() const {
        switch(this->rowIndex) {
          case 0: {
            return Vector4<TScalar>(
              this->matrix->M11, this->matrix->M12, this->matrix->M13, this->matrix->M14
            );
          }
          case 1: {
            return Vector4<TScalar>(
              this->matrix->M21, this->matrix->M22, this->matrix->M23, this->matrix->M24
            );
          }
          case 2: {
            return Vector4<TScalar>(
              this->matrix->M31, this->matrix->M32, this->matrix->M33, this->matrix->M34
            );
          }
          case 3: {
            return Vector4<TScalar>(
              this->matrix->M41, this->matrix->M42, this->matrix->M43, this->matrix->M44
            );
          }
        }
      }

      /// <summary>Accesses the specified column in the row assigned to the accessor</summary>
      /// <param name="columnIndex">Column in which the accessor will access a row</param>
      /// <returns>The matrix element at the specified column</returns>
      public: TScalar &operator[](std::size_t columnIndex) {
        if(columnIndex >= 4) {
          throw std::out_of_range("Invalid column index");
        }

        switch((rowIndex << 4) | columnIndex) {
          case 0x0000: { return matrix->M11; }
          case 0x0001: { return matrix->M12; }
          case 0x0002: { return matrix->M13; }
          case 0x0003: { return matrix->M14; }

          case 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }
          case 0x0103: { return matrix->M24; }

          case 0x0200: { return matrix->M31; }
          case 0x0201: { return matrix->M32; }
          case 0x0202: { return matrix->M33; }
          case 0x0203: { return matrix->M34; }

          case 0x0300: { return matrix->M41; }
          case 0x0301: { return matrix->M42; }
          case 0x0302: { return matrix->M43; }
          case 0x0303: { return matrix->M44; }
        }
      }

      /// <summary>Accesses the specified column in the row assigned to the accessor</summary>
      /// <param name="columnIndex">Column in which the accessor will access a row</param>
      /// <returns>The matrix element at the specified column</returns>
      public: const TScalar &operator[](std::size_t columnIndex) const {
        if(columnIndex >= 4) {
          throw std::out_of_range("Invalid column index");
        }

        switch((rowIndex << 4) | columnIndex) {
          case 0x0000: { return matrix->M11; }
          case 0x0001: { return matrix->M12; }
          case 0x0002: { return matrix->M13; }
          case 0x0003: { return matrix->M14; }

          case 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }
          case 0x0103: { return matrix->M24; }

          case 0x0200: { return matrix->M31; }
          case 0x0201: { return matrix->M32; }
          case 0x0202: { return matrix->M33; }
          case 0x0203: { return matrix->M34; }

          case 0x0300: { return matrix->M41; }
          case 0x0301: { return matrix->M42; }
          case 0x0302: { return matrix->M43; }
          case 0x0303: { return matrix->M44; }
        }
      }

      /// <summary>Matrix the accessor will access</summary>
      private: Matrix44 &matrix;
      /// <summary>Index of the row in which the accessor will access an element<summary>
      private: std::size_t rowIndex;

    };

    #pragma endregion // class MatrixRowAccessor

    #pragma region class ConstMatrixRowAccessor

    /// <summary>Accesses a single row in an immutable matrix</summary>
    public: class ConstMatrixRowAccessor {

      /// <summary>Initializes a new matrix row accessor</summary>
      /// <param name="matrix">Matrix that the row accessor will access</param>
      /// <param name="rowIndex">Index of the row the row accessor will access</param>
      public: ConstMatrixRowAccessor(const Matrix44 &matrix, std::size_t rowIndex) :
        matrix(matrix),
        rowIndex(rowIndex) {
        if(rowIndex >= 4) {
          throw std::out_of_range("Invalid row index");
        }
      }

      /// <summary>Accesses an entire row of the matrix as a 4D vector</summary>
      public: operator const Vector4<TScalar>() const {
        switch(this->rowIndex) {
          case 0: {
            return Vector4<TScalar>(
              this->matrix->M11, this->matrix->M12, this->matrix->M13, this->matrix->M14
            );
          }
          case 1: {
            return Vector4<TScalar>(
              this->matrix->M21, this->matrix->M22, this->matrix->M23, this->matrix->M24
            );
          }
          case 2: {
            return Vector4<TScalar>(
              this->matrix->M31, this->matrix->M32, this->matrix->M33, this->matrix->M34
            );
          }
          case 3: {
            return Vector4<TScalar>(
              this->matrix->M41, this->matrix->M42, this->matrix->M43, this->matrix->M44
            );
          }
        }
      }

      /// <summary>Accesses the specified column in the row assigned to the accessor</summary>
      /// <param name="columnIndex">Column in which the accessor will access a row</param>
      /// <returns>The matrix element at the specified column</returns>
      public: const TScalar &operator[](std::size_t columnIndex) const {
        if(columnIndex >= 4) {
          throw std::out_of_range("Invalid column index");
        }

        switch((rowIndex << 4) | columnIndex) {
          case 0x0000: { return matrix->M11; }
          case 0x0001: { return matrix->M12; }
          case 0x0002: { return matrix->M13; }
          case 0x0003: { return matrix->M14; }

          case 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }
          case 0x0103: { return matrix->M24; }

          case 0x0200: { return matrix->M31; }
          case 0x0201: { return matrix->M32; }
          case 0x0202: { return matrix->M33; }
          case 0x0203: { return matrix->M34; }

          case 0x0300: { return matrix->M41; }
          case 0x0301: { return matrix->M42; }
          case 0x0302: { return matrix->M43; }
          case 0x0303: { return matrix->M44; }
        }
      }

      /// <summary>Matrix the accessor will access</summary>
      private: const Matrix44 &matrix;
      /// <summary>Index of the row in which the accessor will access an element<summary>
      private: std::size_t rowIndex;

    };

    #pragma endregion // class ConstMatrixRowAccessor

    /// <summary>An empty matrix</summary>
    public: static const Matrix44 Empty;

    /// <summary>The identity matrix</summary>
    public: static const Matrix44 Identity;

    /// <summary>Constructs an uninitialized 4x4 matrix</summary>
    public: Matrix44() {}

    /// <summary>Initializes a new 4x4 matrix</summary>
    /// <param name="m">Existing matrix that will be copied</param>
    public: Matrix44(TScalar m[4][4]) :
      M11(m[0][0]), M12(m[0][1]), M13(m[0][2]), M14(m[0][3]),
      M21(m[1][0]), M22(m[1][1]), M23(m[1][2]), M24(m[1][3]),
      M31(m[2][0]), M32(m[2][1]), M33(m[2][2]), M34(m[2][3]),
      M41(m[3][0]), M42(m[3][1]), M43(m[3][2]), M44(m[3][3]) {}

    /// <summary>Initializes a new 4x4 matrix</summary>
    /// <param name="m11">Value for the element in row 1, column 1</param>
    /// <param name="m12">Value for the element in row 1, column 2</param>
    /// <param name="m13">Value for the element in row 1, column 3</param>
    /// <param name="m14">Value for the element in row 1, column 4</param>
    /// <param name="m21">Value for the element in row 2, column 1</param>
    /// <param name="m22">Value for the element in row 2, column 2</param>
    /// <param name="m23">Value for the element in row 2, column 3</param>
    /// <param name="m24">Value for the element in row 2, column 4</param>
    /// <param name="m31">Value for the element in row 3, column 1</param>
    /// <param name="m32">Value for the element in row 3, column 2</param>
    /// <param name="m33">Value for the element in row 3, column 3</param>
    /// <param name="m34">Value for the element in row 3, column 4</param>
    /// <param name="m41">Value for the element in row 4, column 1</param>
    /// <param name="m42">Value for the element in row 4, column 2</param>
    /// <param name="m43">Value for the element in row 4, column 3</param>
    /// <param name="m44">Value for the element in row 4, column 4</param>
    public: Matrix44(
      TScalar m11, TScalar m12, TScalar m13, TScalar m14,
      TScalar m21, TScalar m22, TScalar m23, TScalar m24,
      TScalar m31, TScalar m32, TScalar m33, TScalar m34,
      TScalar m41, TScalar m42, TScalar m43, TScalar m44
    ) :
      M11(m11), M12(m12), M13(m13), M14(m14),
      M21(m21), M22(m22), M23(m23), M24(m24),
      M31(m31), M32(m32), M33(m33), M34(m34),
      M41(m41), M42(m42), M43(m43), M44(m44) {}

    /// <summary>Creates a right-handed orthogonal projection matrix</summary>
    /// <param name="viewSize">Size of the view shown by the projection matrix</param>
    /// <param name="near">Near clipping plane distance</param>
    /// <param name="far">Far clipping plane distance</param>
    /// <returns>An orthogonal projection matrix</returns>
    public: static Matrix44 CreateOrthogonalProjection(
      const Areas::Rectangle2<TScalar> &viewSize,
      TScalar near = TScalar(1) / TScalar(100), TScalar far = TScalar(100)
    );

    /// <summary>Creates a right-handed perspective projection matrix</summary>
    /// <param name="fieldOfViewRadians">Field of view in radians</param>
    /// <param name="aspectRatio">Aspect ratio of the view area</param>
    /// <param name="near">Near clipping plane distance</param>
    /// <param name="far">Far clipping plane distance</param>
    /// <returns>A perspective projection matrix</returns>
    public: static Matrix44 CreatePerspectiveProjection(
      TScalar fieldOfViewRadians, TScalar aspectRatio,
      TScalar near = TScalar(1) / TScalar(100), TScalar far = TScalar(100)
    );

    /// <summary>Creates a rotation matrix that rotates on the X axis</summary>
    /// <param name="angleRadians">Angle by which the matrix rotates</param>
    /// <returns>A rotation matrix</returns>
    public: static Matrix44 CreateXRotation(TScalar angleRadians);

    /// <summary>Creates a rotation matrix that rotates on the Y axis</summary>
    /// <param name="angleRadians">Angle by which the matrix rotates</param>
    /// <returns>A rotation matrix</returns>
    public: static Matrix44 CreateYRotation(TScalar angleRadians);

    /// <summary>Creates a rotation matrix that rotates on the Z axis</summary>
    /// <param name="angleRadians">Angle by which the matrix rotates</param>
    /// <returns>A rotation matrix</returns>
    public: static Matrix44 CreateZRotation(TScalar angleRadians);

    /// <summary>Creates a translation matrix</summary>
    /// <param name="x">X offset the matrix will translate by</param>
    /// <param name="y">Y offset the matrix will translate by</param>
    /// <param name="z">Z offset the matrix will translate by</param>
    /// <returns>A matrix that translates by the specified offset</returns>
    public: static Matrix44 CreateTranslation(TScalar x, TScalar y, TScalar z);

    /// <summary>Creates a translation matrix</summary>
    /// <param name="translation">Offset the matrix will translate by</param>
    /// <returns>A matrix that translates by the specified offset</returns>
    public: static Matrix44 CreateTranslation(const Vector3<TScalar> &translation);

    /// <summary>Changes the matrix orientation so it points at the target</summary>
    /// <param name="target">Target the matrix will point at</param>
    /// <param name="up">Up axis the camera will be oriented to</param>
    public: void LookAt(
      const Point3<TScalar> &target, const Vector3<TScalar> &up = Vector3<TScalar>::Up
    );

    /// <summary>Transposes the matrix; rows become columns and vice versa</summary>
    public: void Transpose();

    /// <summary>Multiplies the matrix by another matrix</summary>
    /// <param name="other">Other matrix this matrix will be multiplied with</param>
    /// <returns>This result of the matrix multiplication</returns>
    public: Matrix44 operator *(const Matrix44 &other);

    /// <summary>Matrix row 1 column 1, storing the right vector's X coordinate</summary>
    public: TScalar M11;
    /// <summary>Matrix row 1 column 2, storing the right vector's Y coordinate</summary>
    public: TScalar M12;
    /// <summary>Matrix row 1 column 3, storing the right vector's Z coordinate</summary>
    public: TScalar M13;
    /// <summary>Matrix row 1 column 4, storing the right vector's W coordinate</summary>
    public: TScalar M14;

    /// <summary>Matrix row 2 column 1, storing the up vector's X coordinate</summary>
    public: TScalar M21;
    /// <summary>Matrix row 2 column 2, storing the up vector's Y coordinate</summary>
    public: TScalar M22;
    /// <summary>Matrix row 2 column 3, storing the up vector's Z coordinate</summary>
    public: TScalar M23;
    /// <summary>Matrix row 2 column 4, storing the up vector's W coordinate</summary>
    public: TScalar M24;

    /// <summary>Matrix row 3 column 1, storing the forward vector's X coordinate</summary>
    public: TScalar M31;
    /// <summary>Matrix row 3 column 2, storing the forward vector's Y coordinate</summary>
    public: TScalar M32;
    /// <summary>Matrix row 3 column 3, storing the forward vector's Z coordinate</summary>
    public: TScalar M33;
    /// <summary>Matrix row 3 column 4, storing the forward vector's W coordinate</summary>
    public: TScalar M34;

    /// <summary>Matrix row 4 column 1, storing the translation's X coordinate</summary>
    public: TScalar M41;
    /// <summary>Matrix row 4 column 2, storing the translation's Y coordinate</summary>
    public: TScalar M42;
    /// <summary>Matrix row 4 column 3, storing the translation's Z coordinate</summary>
    public: TScalar M43;
    /// <summary>Matrix row 4 column 4, storing the translation's W coordinate</summary>
    public: TScalar M44;

  };

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  const Matrix44<TScalar> Matrix44<TScalar>::Empty(
    0, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0
  );

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  const Matrix44<TScalar> Matrix44<TScalar>::Identity(
    1, 0, 0, 0,
    0, 1, 0, 0,
    0, 0, 1, 0,
    0, 0, 0, 1
  );

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateOrthogonalProjection(
    const Areas::Rectangle2<TScalar> &viewSize,
    TScalar near /* = TScalar(0.01) */, TScalar far /* = TScalar(100) */
  ) {
    TScalar range = 1 / (near - far);

    return Matrix44(
      2 / viewSize.GetWidth(),                        0,            0, 0,
                            0, 2 / viewSize.GetHeight(),            0, 0,
                            0,                        0,        range, 0,
                            0,                        0, range * near, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreatePerspectiveProjection(
    TScalar fieldOfViewRadians, TScalar aspectRatio,
    TScalar near_ /* = TScalar(0.01) */, TScalar far_ /* = TScalar(100.0) */
  ) {
    fieldOfViewRadians /= 2;
    TScalar fieldOfViewSine = Math<TScalar>::Sine(fieldOfViewRadians);
    TScalar fieldOfViewCosine = Math<TScalar>::Cosine(fieldOfViewRadians);

    TScalar height = fieldOfViewCosine / fieldOfViewSine;
    TScalar width = height / aspectRatio;
    TScalar range = far_ / (near_ - far_);

    return Matrix44(
      width,      0,             0,  0,
          0, height,             0,  0,
          0,      0,         range, -1,
          0,      0, range * near_,  0
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateXRotation(TScalar angleRadians) {
    TScalar sine = Math<TScalar>::Sine(angleRadians);
    TScalar cosine = Math<TScalar>::Cosine(angleRadians);

    return Matrix44(
      1,      0,      0, 0,
      0, cosine,   sine, 0,
      0,  -sine, cosine, 0,
      0,      0,      0, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateYRotation(TScalar angleRadians) {
    TScalar sine = Math<TScalar>::Sine(angleRadians);
    TScalar cosine = Math<TScalar>::Cosine(angleRadians);

    return Matrix44(
      cosine, 0,  -sine, 0,
           0, 1,      0, 0,
        sine, 0, cosine, 0,
           0, 0,      0, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateZRotation(TScalar angleRadians) {
    TScalar sine = Math<TScalar>::Sine(angleRadians);
    TScalar cosine = Math<TScalar>::Cosine(angleRadians);

    return Matrix44(
      cosine,   sine, 0, 0,
       -sine, cosine, 0, 0,
           0,      0, 1, 0,
           0,      0, 0, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateTranslation(TScalar x, TScalar y, TScalar z) {
    return Matrix44<TScalar>(
      1, 0, 0, 0,
      0, 1, 0, 0,
      0, 0, 1, 0,
      x, y, z, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::CreateTranslation(const Vector3<TScalar> &translation) {
    return Matrix44<TScalar>(
                  1,             0,             0, 0,
                  0,             1,             0, 0,
                  0,             0,             1, 0,
      translation.X, translation.Y, translation.Z, 1
    );
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  void Matrix44<TScalar>::LookAt(
    const Point3<TScalar> &target, const Vector3<TScalar> &worldUp /* = Vector3<TScalar>::Up */
  ) {
    // TODO: I think this constructs an already inverted matrix. Change it!
    //   I want this method to construct a normal matrix so it can be used to orient
    //   arbitrary objects towards something. If the user needs a view matrix, he should
    //   explicitly invert it.

    Vector3<TScalar> forward(
      this->M41 - target.X,
      this->M42 - target.Y,
      this->M43 - target.Z
    );
    forward.Normalize();

    Vector3<TScalar> right = worldUp.Cross(forward).GetNormalized();
    Vector3<TScalar> up = forward.Cross(right);

    Vector3<TScalar> negativePosition(-this->M41, -this->M42, -this->M43);

    this->M11 = right.X;
    this->M21 = right.Y;
    this->M31 = right.Z;
    this->M41 = right.Dot(negativePosition);

    this->M12 = up.X;
    this->M22 = up.Y;
    this->M32 = up.Z;
    this->M42 = up.Dot(negativePosition);

    this->M13 = forward.X;
    this->M23 = forward.Y;
    this->M33 = forward.Z;
    this->M43 = forward.Dot(negativePosition);
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  void Matrix44<TScalar>::Transpose() {
    float temp;

    temp = this->M12; this->M12 = this->M21; this->M21 = temp;
    temp = this->M13; this->M13 = this->M31; this->M31 = temp;
    temp = this->M14; this->M14 = this->M41; this->M41 = temp;

    temp = this->M23; this->M23 = this->M32; this->M32 = temp;
    temp = this->M24; this->M24 = this->M42; this->M42 = temp;

    temp = this->M34; this->M34 = this->M43; this->M43 = temp;
  }

  // ------------------------------------------------------------------------------------------- //

  template <typename TScalar>
  Matrix44<TScalar> Matrix44<TScalar>::operator *(const Matrix44 &other) {
    Matrix44<TScalar> result;
    TScalar x, y, z, w;

    x = this->M11; y = this->M12; z = this->M13; w = this->M14;
    result.M11 = (x * other.M11) + (y * other.M21) + (z * other.M31) + (w * other.M41);
    result.M12 = (x * other.M12) + (y * other.M22) + (z * other.M32) + (w * other.M42);
    result.M13 = (x * other.M13) + (y * other.M23) + (z * other.M33) + (w * other.M43);
    result.M14 = (x * other.M14) + (y * other.M24) + (z * other.M34) + (w * other.M44);

    x = this->M21; y = this->M22; z = this->M23; w = this->M24;
    result.M21 = (x * other.M11) + (y * other.M21) + (z * other.M31) + (w * other.M41);
    result.M22 = (x * other.M12) + (y * other.M22) + (z * other.M32) + (w * other.M42);
    result.M23 = (x * other.M13) + (y * other.M23) + (z * other.M33) + (w * other.M43);
    result.M24 = (x * other.M14) + (y * other.M24) + (z * other.M34) + (w * other.M44);

    x = this->M31; y = this->M32; z = this->M33; w = this->M34;
    result.M31 = (x * other.M11) + (y * other.M21) + (z * other.M31) + (w * other.M41);
    result.M32 = (x * other.M12) + (y * other.M22) + (z * other.M32) + (w * other.M42);
    result.M33 = (x * other.M13) + (y * other.M23) + (z * other.M33) + (w * other.M43);
    result.M34 = (x * other.M14) + (y * other.M24) + (z * other.M34) + (w * other.M44);

    x = this->M41; y = this->M42; z = this->M43; w = this->M44;
    result.M41 = (x * other.M11) + (y * other.M21) + (z * other.M31) + (w * other.M41);
    result.M42 = (x * other.M12) + (y * other.M22) + (z * other.M32) + (w * other.M42);
    result.M43 = (x * other.M13) + (y * other.M23) + (z * other.M33) + (w * other.M43);
    result.M44 = (x * other.M14) + (y * other.M24) + (z * other.M34) + (w * other.M44);

    return result;
  }

  // ------------------------------------------------------------------------------------------- //

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_MATRIX44_H