#pragma once

#ifndef TCG_RECT_H
#define TCG_RECT_H

#include "point.h"
#include "size.h"

// STD includes
#include <limits>

namespace tcg {

//**********************************************************************************
//    Bidimensional Rect  class
//**********************************************************************************

template <typename T>
struct RectT {
  T x0, y0, x1, y1;

public:
  RectT() : x0((std::numeric_limits<T>::max)()), y0(x0), x1(-x0), y1(x1) {}
  RectT(T x0_, T y0_, T x1_, T y1_) : x0(x0_), y0(y0_), x1(x1_), y1(y1_) {}
  RectT(const PointT<T> &p0, const PointT<T> &p1)
      : x0(p0.x), y0(p0.y), x1(p1.x), y1(p1.y) {}
  RectT(const PointT<T> &p0, const SizeT<T> &size)
      : x0(p0.x), y0(p0.y), x1(p0.x + size.w), y1(p0.y + size.h) {}

  bool empty() const { return (x1 <= x0) || (y1 <= y0); }

  PointT<T> p0() const { return PointT<T>(x0, y0); }
  PointT<T> p1() const { return PointT<T>(x1, y1); }
  PointT<T> center() const { return PointT<T>((x0 + x1) / 2, (y0 + y1) / 2); }

  T width() const { return x1 - x0; }
  T height() const { return y1 - y0; }
  SizeT<T> size() const { return SizeT<T>(width(), height()); }

  bool operator==(const RectT &other) const {
    return x0 == other.x0 && y0 == other.y0 && x1 == other.x1 && y1 == other.y1;
  }
  bool operator!=(const RectT &other) const { return !operator==(other); }

  RectT &operator+=(const PointT<T> &p) {
    x0 += p.x, y0 += p.y, x1 += p.x, y1 += p.y;
    return *this;
  }
  RectT &operator-=(const PointT<T> &p) {
    x0 -= p.x, y0 -= p.y, x1 -= p.x, y1 -= p.y;
    return *this;
  }

  friend RectT<T> operator+(const RectT<T> &r, const tcg::PointT<T> &p) {
    return RectT<T>(r.x0 + p.x, r.y0 + p.y, r.x1 + p.x, r.y1 + p.y);
  }
  friend RectT<T> operator-(const RectT<T> &r, const tcg::PointT<T> &p) {
    return RectT<T>(r.x0 - p.x, r.y0 - p.y, r.x1 - p.x, r.y1 - p.y);
  }
  friend RectT<T> operator+(const tcg::PointT<T> &p, const RectT<T> &r) {
    return RectT<T>(p.x + r.x0, p.y + r.y0, p.x + r.x1, p.y + r.y1);
  }
  friend RectT<T> operator-(const tcg::PointT<T> &p, const RectT<T> &r) {
    return RectT<T>(p.x - r.x0, p.y - r.y0, p.x - r.x1, p.y - r.y1);
  }

  template <typename K>
  RectT &operator*=(K k) {
    x0 *= k, y0 *= k, x1 *= k, y1 *= k;
    return *this;
  }

  template <typename K>
  friend RectT<T> operator*(const RectT<T> &r, K k) {
    return RectT<T>(r.x0 * k, r.y0 * k, r.x1 * k, r.y1 * k);
  }
  template <typename K>
  friend RectT<T> operator*(K k, const RectT<T> &r) {
    return RectT<T>(k * r.x0, k * r.y0, k * r.x1, k * r.y1);
  }

  RectT &operator|=(const RectT &other) {
    if (x0 > other.x0) x0 = other.x0;
    if (y0 > other.y0) y0 = other.y0;
    if (x1 < other.x1) x1 = other.x1;
    if (y1 < other.y1) y1 = other.y1;
    return *this;
  }

  RectT &operator&=(const RectT &other) {
    if (x0 < other.x0) x0 = other.x0;
    if (y0 < other.y0) y0 = other.y0;
    if (x1 > other.x1) x1 = other.x1;
    if (y1 > other.y1) y1 = other.y1;
    return *this;
  }

  RectT &operator|=(const PointT<T> &p) {
    return operator|=(RectT(p.x, p.y, p.x, p.y));
  }
  RectT &operator&=(const PointT<T> &p) {
    return operator&=(RectT(p.x, p.y, p.x, p.y));
  }

  friend RectT<T> operator|(const RectT<T> &a, const RectT<T> &b) {
    return RectT<T>(a) |= b;
  }
  friend RectT<T> operator&(const RectT<T> &a, const RectT<T> &b) {
    return RectT<T>(a) &= b;
  }

  friend RectT<T> operator|(const RectT<T> &r, const PointT<T> &p) {
    return RectT<T>(r) |= p;
  }
  friend RectT<T> operator&(const RectT<T> &r, const PointT<T> &p) {
    return RectT<T>(r) &= p;
  }
  friend RectT<T> operator|(const PointT<T> &p, const RectT<T> &r) {
    return RectT<T>(r) |= p;
  }
  friend RectT<T> operator&(const PointT<T> &p, const RectT<T> &r) {
    return RectT<T>(r) &= p;
  }
};

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

typedef RectT<double> RectD;
typedef RectT<int> RectI;
typedef RectI Rect;

//**********************************************************************************
//    Tridimensional Rect  class
//**********************************************************************************

template <typename T>
struct Rect3T {
  T x0, y0, z0, x1, y1, z1;

public:
  Rect3T()
      : x0((std::numeric_limits<T>::max)())
      , y0(x0)
      , z0(x0)
      , x1(-x0)
      , y1(x1)
      , z1(x1) {}
  Rect3T(T x0_, T y0_, T z0_, T x1_, T y1_, T z1_)
      : x0(x0_), y0(y0_), z0(z0_), x1(x1_), y1(y1_), z1(z1_) {}
  Rect3T(const Point3T<T> &p0, const Point3T<T> &p1)
      : x0(p0.x), y0(p0.y), z0(p0.z) x1(p1.x), y1(p1.y), z1(p1.z) {}
  Rect3T(const Point3T<T> &p0, const Size3T<T> &size)
      : x0(p0.x)
      , y0(p0.y)
      , z0(p0.z)
      , x1(p0.x + size.w)
      , y1(p0.y + size.h)
      , z1(p0.z + size.d) {}

  bool empty() const { return (x1 <= x0) || (y1 <= y0) || (z1 <= z0); }

  Point3T<T> p0() const { return Point3T<T>(x0, y0, z0); }
  Point3T<T> p1() const { return Point3T<T>(x1, y1, z1); }
  Point3T<T> center() const {
    return Point3T<T>((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2);
  }

  T width() const { return x1 - x0; }
  T height() const { return y1 - y0; }
  T depth() const { return z1 - z0; }
  Size3T<T> size() const { return Size3T<T>(width(), height(), depth()); }

  bool operator==(const Rect3T &other) const {
    return x0 == other.x0 && y0 == other.y0 && z0 == other.z0 &&
           x1 == other.x1 && y1 == other.y1 && z1 == other.z1;
  }
  bool operator!=(const Rect3T &other) const { return !operator==(other); }

  Rect3T &operator+=(const Point3T<T> &p) {
    x0 += p.x, y0 += p.y, z0 += p.z, x1 += p.x, y1 += p.y, z1 += p.z;
    return *this;
  }
  Rect3T &operator-=(const Point3T<T> &p) {
    x0 -= p.x, y0 -= p.y, z0 -= p.z, x1 -= p.x, y1 -= p.y, z1 -= p.z;
    return *this;
  }

  friend Rect3T<T> operator+(const Rect3T<T> &r, const tcg::Point3T<T> &p) {
    return Rect3T<T>(r.x0 + p.x, r.y0 + p.y, r.z0 + p.z, r.x1 + p.x, r.y1 + p.y,
                     r.z1 + p.z);
  }
  friend Rect3T<T> operator-(const Rect3T<T> &r, const tcg::Point3T<T> &p) {
    return Rect3T<T>(r.x0 - p.x, r.y0 - p.y, r.z0 - p.z, r.x1 - p.x, r.y1 - p.y,
                     r.z1 - p.z);
  }
  friend Rect3T<T> operator+(const tcg::Point3T<T> &p, const Rect3T<T> &r) {
    return Rect3T<T>(p.x + r.x0, p.x + r.y0, p.x + r.z0, p.x + r.x1 + p.x, r.y1,
                     p.x + r.z1);
  }
  friend Rect3T<T> operator-(const tcg::Point3T<T> &p, const Rect3T<T> &r) {
    return Rect3T<T>(p.x - r.x0, p.y - r.y0, p.z - r.z0, p.x - r.x1, p.y - r.y1,
                     p.z - r.z1);
  }

  template <typename K>
  Rect3T &operator*=(K k) {
    x0 *= k, y0 *= k, z0 *= k, x1 *= k, y1 *= k, z1 *= k;
    return *this;
  }

  template <typename K>
  friend Rect3T<T> operator*(const Rect3T<T> &r, K k) {
    return RectT<T>(r.x0 * k, r.y0 * k, r.z0 * k, r.x1 * k, r.y1 * k, r.z1 * k);
  }
  template <typename K>
  friend Rect3T<T> operator*(K k, const Rect3T<T> &r) {
    return RectT<T>(k * r.x0, k * r.y0, k * r.z0, k * r.x1, k * r.y1, k * r.z1);
  }

  Rect3T &operator|=(const Rect3T &other) {
    if (x0 > other.x0) x0 = other.x0;
    if (y0 > other.y0) y0 = other.y0;
    if (z0 > other.z0) z0 = other.z0;
    if (x1 < other.x1) x1 = other.x1;
    if (y1 < other.y1) y1 = other.y1;
    if (z1 < other.z1) z1 = other.z1;
    return *this;
  }

  Rect3T &operator&=(const Rect3T &other) {
    if (x0 < other.x0) x0 = other.x0;
    if (y0 < other.y0) y0 = other.y0;
    if (z0 < other.z0) z0 = other.z0;
    if (x1 > other.x1) x1 = other.x1;
    if (y1 > other.y1) y1 = other.y1;
    if (z1 > other.z1) z1 = other.z1;
    return *this;
  }

  Rect3T &operator|=(const Point3T<T> &p) {
    return operator|=(RectT(p.x, p.y, p.z, p.x, p.y, p.z));
  }
  Rect3T &operator&=(const Point3T<T> &p) {
    return operator&=(RectT(p.x, p.y, p.z, p.x, p.y, p.z));
  }

  friend Rect3T<T> operator|(const Rect3T<T> &a, const Rect3T<T> &b) {
    return Rect3T<T>(a) |= b;
  }
  friend Rect3T<T> operator&(const Rect3T<T> &a, const Rect3T<T> &b) {
    return Rect3T<T>(a) &= b;
  }

  friend Rect3T<T> operator|(const Rect3T<T> &r, const Point3T<T> &p) {
    return Rect3T<T>(r) |= p;
  }
  friend Rect3T<T> operator&(const Rect3T<T> &r, const Point3T<T> &p) {
    return Rect3T<T>(r) &= p;
  }
  friend Rect3T<T> operator|(const Point3T<T> &p, const Rect3T<T> &r) {
    return Rect3T<T>(r) |= p;
  }
  friend Rect3T<T> operator&(const Point3T<T> &p, const Rect3T<T> &r) {
    return Rect3T<T>(r) &= p;
  }
};

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

typedef Rect3T<double> Rect3D;
typedef Rect3T<int> Rect3I;
typedef RectI Rect;

}  // namespace tcg

#endif  // TCG_RECT_H