#pragma once

#ifndef TCG_RECT_H

#define TCG_RECT_H

#include "point.h"

#include "size.h"

// STD includes

#include <limits></limits>

namespace tcg {

//**********************************************************************************

//    Bidimensional Rect  class

//**********************************************************************************

template <typename t=""></typename>

struct RectT {

  T x0, y0, x1, y1;

public:

  RectT() : x0((std::numeric_limits<t>::max)()), y0(x0), x1(-x0), y1(x1) {}</t>

  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)</t></t>

      : x0(p0.x), y0(p0.y), x1(p1.x), y1(p1.y) {}

  RectT(const PointT<t> &p0, const SizeT<t> &size)</t></t>

      : 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); }</t></t>

  PointT<t> p1() const { return PointT<t>(x1, y1); }</t></t>

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

  T width() const { return x1 - x0; }

  T height() const { return y1 - y0; }

  SizeT<t> size() const { return SizeT<t>(width(), height()); }</t></t>

  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) {</t>

    x0 += p.x, y0 += p.y, x1 += p.x, y1 += p.y;

    return *this;

  }

  RectT &operator-=(const PointT<t> &p) {</t>

    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) {</t></t></t>

    return RectT<t>(r.x0 + p.x, r.y0 + p.y, r.x1 + p.x, r.y1 + p.y);</t>

  }

  friend RectT<t> operator-(const RectT<t> &r, const tcg::PointT<t> &p) {</t></t></t>

    return RectT<t>(r.x0 - p.x, r.y0 - p.y, r.x1 - p.x, r.y1 - p.y);</t>

  }

  friend RectT<t> operator+(const tcg::PointT<t> &p, const RectT<t> &r) {</t></t></t>

    return RectT<t>(p.x + r.x0, p.y + r.y0, p.x + r.x1, p.y + r.y1);</t>

  }

  friend RectT<t> operator-(const tcg::PointT<t> &p, const RectT<t> &r) {</t></t></t>

    return RectT<t>(p.x - r.x0, p.y - r.y0, p.x - r.x1, p.y - r.y1);</t>

  }

  template <typename k=""></typename>

  RectT &operator*=(K k) {

    x0 *= k, y0 *= k, x1 *= k, y1 *= k;

    return *this;

  }

  template <typename k=""></typename>

  friend RectT<t> operator*(const RectT<t> &r, K k) {</t></t>

    return RectT<t>(r.x0 * k, r.y0 * k, r.x1 * k, r.y1 * k);</t>

  }

  template <typename k=""></typename>

  friend RectT<t> operator*(K k, const RectT<t> &r) {</t></t>

    return RectT<t>(k * r.x0, k * r.y0, k * r.x1, k * r.y1);</t>

  }

  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) {</t>

    return operator|=(RectT(p.x, p.y, p.x, p.y));

  }

  RectT &operator&=(const PointT<t> &p) {</t>

    return operator&=(RectT(p.x, p.y, p.x, p.y));

  }

  friend RectT<t> operator|(const RectT<t> &a, const RectT<t> &b) {</t></t></t>

    return RectT<t>(a) |= b;</t>

  }

  friend RectT<t> operator&(const RectT<t> &a, const RectT<t> &b) {</t></t></t>

    return RectT<t>(a) &= b;</t>

  }

  friend RectT<t> operator|(const RectT<t> &r, const PointT<t> &p) {</t></t></t>

    return RectT<t>(r) |= p;</t>

  }

  friend RectT<t> operator&(const RectT<t> &r, const PointT<t> &p) {</t></t></t>

    return RectT<t>(r) &= p;</t>

  }

  friend RectT<t> operator|(const PointT<t> &p, const RectT<t> &r) {</t></t></t>

    return RectT<t>(r) |= p;</t>

  }

  friend RectT<t> operator&(const PointT<t> &p, const RectT<t> &r) {</t></t></t>

    return RectT<t>(r) &= p;</t>

  }

};

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

typedef RectT<double> RectD;</double>

typedef RectT<int> RectI;</int>

typedef RectI Rect;

//**********************************************************************************

//    Tridimensional Rect  class

//**********************************************************************************

template <typename t=""></typename>

struct Rect3T {

  T x0, y0, z0, x1, y1, z1;

public:

  Rect3T()

      : x0((std::numeric_limits<t>::max)())</t>

      , 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)</t></t>

      : 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)</t></t>

      : 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); }</t></t>

  Point3T<t> p1() const { return Point3T<t>(x1, y1, z1); }</t></t>

  Point3T<t> center() const {</t>

    return Point3T<t>((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2);</t>

  }

  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()); }</t></t>

  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) {</t>

    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) {</t>

    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) {</t></t></t>

    return Rect3T<t>(r.x0 + p.x, r.y0 + p.y, r.z0 + p.z, r.x1 + p.x, r.y1 + p.y,</t>

                     r.z1 + p.z);

  }

  friend Rect3T<t> operator-(const Rect3T<t> &r, const tcg::Point3T<t> &p) {</t></t></t>

    return Rect3T<t>(r.x0 - p.x, r.y0 - p.y, r.z0 - p.z, r.x1 - p.x, r.y1 - p.y,</t>

                     r.z1 - p.z);

  }

  friend Rect3T<t> operator+(const tcg::Point3T<t> &p, const Rect3T<t> &r) {</t></t></t>

    return Rect3T<t>(p.x + r.x0, p.x + r.y0, p.x + r.z0, p.x + r.x1 + p.x, r.y1,</t>

                     p.x + r.z1);

  }

  friend Rect3T<t> operator-(const tcg::Point3T<t> &p, const Rect3T<t> &r) {</t></t></t>

    return Rect3T<t>(p.x - r.x0, p.y - r.y0, p.z - r.z0, p.x - r.x1, p.y - r.y1,</t>

                     p.z - r.z1);

  }

  template <typename k=""></typename>

  Rect3T &operator*=(K k) {

    x0 *= k, y0 *= k, z0 *= k, x1 *= k, y1 *= k, z1 *= k;

    return *this;

  }

  template <typename k=""></typename>

  friend Rect3T<t> operator*(const Rect3T<t> &r, K k) {</t></t>

    return RectT<t>(r.x0 * k, r.y0 * k, r.z0 * k, r.x1 * k, r.y1 * k, r.z1 * k);</t>

  }

  template <typename k=""></typename>

  friend Rect3T<t> operator*(K k, const Rect3T<t> &r) {</t></t>

    return RectT<t>(k * r.x0, k * r.y0, k * r.z0, k * r.x1, k * r.y1, k * r.z1);</t>

  }

  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) {</t>

    return operator|=(RectT(p.x, p.y, p.z, p.x, p.y, p.z));

  }

  Rect3T &operator&=(const Point3T<t> &p) {</t>

    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) {</t></t></t>

    return Rect3T<t>(a) |= b;</t>

  }

  friend Rect3T<t> operator&(const Rect3T<t> &a, const Rect3T<t> &b) {</t></t></t>

    return Rect3T<t>(a) &= b;</t>

  }

  friend Rect3T<t> operator|(const Rect3T<t> &r, const Point3T<t> &p) {</t></t></t>

    return Rect3T<t>(r) |= p;</t>

  }

  friend Rect3T<t> operator&(const Rect3T<t> &r, const Point3T<t> &p) {</t></t></t>

    return Rect3T<t>(r) &= p;</t>

  }

  friend Rect3T<t> operator|(const Point3T<t> &p, const Rect3T<t> &r) {</t></t></t>

    return Rect3T<t>(r) |= p;</t>

  }

  friend Rect3T<t> operator&(const Point3T<t> &p, const Rect3T<t> &r) {</t></t></t>

    return Rect3T<t>(r) &= p;</t>

  }

};

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

typedef Rect3T<double> Rect3D;</double>

typedef Rect3T<int> Rect3I;</int>

typedef RectI Rect;

}  // namespace tcg

#endif  // TCG_RECT_H