#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_MATRIX33_H
#define NUCLEX_GEOMETRY_MATRIX33_H

#include "Math.h"

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

#include <cassert>

namespace Nuclex { namespace Geometry {

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

  /// <summary>Matrix of 3x3 elements (2D transformation or 3D rotation)</summary>
  /// <remarks>
  ///   <para>
  ///     This kind of matrix can be used to express a complete 2D transformation (rotation
  ///     translation and shear/skew):
  ///   </para>
  ///   <para>
  ///     <code>
  ///        _                          _
  ///       |                            |
  ///       |  cos(phi),  -sin(phi),  x  |
  ///       |  sin(phi),  cos(phi),   y  |      Note: in-memory layout is transposed
  ///       |  0,         0,          1  |
  ///       |_                          _|
  ///     </code>
  ///   </para>
  ///   <para>
  ///     It can also be used to store a complete 3D orientation (without translation):
  ///   </para>
  ///   <para>
  ///     <code>
  ///        _                       _
  ///       |                         |
  ///       |  Right-X,  Up-X,  In-X  |
  ///       |  Right-Y,  Up-Y,  In-Y  |      Note: in-memory layout is transposed
  ///       |  Right-Z,  Up-Z,  In-Z  |
  ///       |_                       _|
  ///     </code>
  ///   </para>
  /// </remarks>
  template <typename TScalar>
  struct Matrix33 {

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

    #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(Matrix33 &matrix, std::size_t rowIndex) :
        matrix(matrix),
        rowIndex(rowIndex) {
        if(rowIndex >= 3) {
          throw std::out_of_range("Invalid row index");
        }
      }

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

      /// <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 >= 2) {
          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 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }

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

      /// <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 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }

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

      /// <summary>Matrix the accessor will access</summary>
      private: Matrix33 &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 Matrix33 &matrix, std::size_t rowIndex) :
        matrix(matrix),
        rowIndex(rowIndex) {
        if(rowIndex >= 3) {
          throw std::out_of_range("Invalid row index");
        }
      }

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

      /// <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 >= 3) {
          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 0x0100: { return matrix->M21; }
          case 0x0101: { return matrix->M22; }
          case 0x0102: { return matrix->M23; }

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

      /// <summary>Matrix the accessor will access</summary>
      private: const Matrix33 &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 Matrix33 Empty;

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

    /// <summary>Constructs an uninitialized 3x3 matrix</summary>
    public: Matrix33() {}

    /// <summary>Initializes a new 3x3 matrix</summary>
    /// <param name="m">Existing matrix that will be copied</param>
    public: Matrix33(TScalar m[3][3]) :
      M11(m[0][0]), M12(m[0][1]), M13(m[0][2]),
      M21(m[1][0]), M22(m[1][1]), M23(m[1][2]),
      M31(m[2][0]), M32(m[2][1]), M33(m[2][2]) {}

    /// <summary>Initializes a new 3x3 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="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="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>
    public: Matrix33(
      TScalar m11, TScalar m12, TScalar m13,
      TScalar m21, TScalar m22, TScalar m23,
      TScalar m31, TScalar m32, TScalar m33
    ) :
      M11(m11), M12(m12), M13(m13),
      M21(m21), M22(m22), M23(m23),
      M31(m31), M32(m32), M33(m33) {}

    /// <summary>Multiplies the matrix with another matrix</summary>
    /// <param name="other">Other matrix this matrix will be multiplied with</param>
    /// <returns>The result of the matrix multiplication</returns>
    public: Matrix33 operator *(const Matrix33 &other) {
      return Matrix33(
        this->M11 * other.M11 + this->M12 * other.M21 + this->M13 * other.M31,
        this->M11 * other.M12 + this->M12 * other.M22 + this->M13 * other.M32,
        this->M11 * other.M13 + this->M12 * other.M23 + this->M13 * other.M33,

        this->M21 * other.M11 + this->M22 * other.M21 + this->M23 * other.M31,
        this->M21 * other.M12 + this->M22 * other.M22 + this->M23 * other.M32,
        this->M21 * other.M13 + this->M22 * other.M23 + this->M23 * other.M33,

        this->M31 * other.M11 + this->M32 * other.M21 + this->M33 * other.M31,
        this->M31 * other.M12 + this->M32 * other.M22 + this->M33 * other.M32,
        this->M31 * other.M13 + this->M32 * other.M23 + this->M33 * other.M33
      );
    }

    /// <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 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 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;

  };

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

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

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

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

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

}} // namespace Nuclex::Geometry

#endif // NUCLEX_GEOMETRY_MATRIX33_H