using System;
using System.Collections.Generic;
using UnityEngine;

namespace BrewMonster.Scripts
{
    public class ARect<T> where T : IComparable<T>
    {
        public T left, top, right, bottom;

        public ARect()
        {
            left = default(T);
            top = default(T);
            right = default(T);
            bottom = default(T);
        }

        public ARect(ARect<T> rc)
        {
            left = rc.left; top = rc.top; right = rc.right; bottom = rc.bottom;
        }

        public ARect(T left, T top, T right, T bottom)
        {
            this.left = left;
            this.top = top;
            this.right = right;
            this.bottom = bottom;
        }

        //	== and != operator
        public static bool operator !=(ARect<T> rc1, ARect<T> rc2)
        {
            return !(rc1 == rc2);
        }
        public static bool operator ==(ARect<T> rc1, ARect<T> rc2)
        {
            return EqualityComparer<T>.Default.Equals(rc1.left, rc2.left) &&
                EqualityComparer<T>.Default.Equals(rc1.top, rc2.top) &&
                EqualityComparer<T>.Default.Equals(rc1.right, rc2.right) &&
                EqualityComparer<T>.Default.Equals(rc1.bottom, rc2.bottom);
        }

        //	+ and - operator
        public static ARect<T> operator +(ARect<T> rc1, ARect<T> rc2)
        {
            dynamic l = rc1.left, t = rc1.top, r = rc1.right, b = rc1.bottom;
            dynamic l2 = rc2.left, t2 = rc2.top, r2 = rc2.right, b2 = rc2.bottom;
            ARect<T> result = new ARect<T>(l + l2, t + t2, r + r2, b + b2);
            return result;
        }
        public static ARect<T> operator -(ARect<T> rc1, ARect<T> rc2)
        {
            return new ARect<T>((dynamic)rc1.left - (dynamic)rc2.left,
                (dynamic)rc1.top - (dynamic)rc2.top,
                (dynamic)rc1.right - (dynamic)rc2.right,
                (dynamic)rc1.bottom - (dynamic)rc2.bottom);
        }
        //public static ARect<T> operator +(ARect<T> rc1, APoint<T> pt)
        //{
        //    return new ARect<T>((dynamic)rc1.left + (dynamic)pt.x,
        //        (dynamic)rc1.top + (dynamic)pt.y,
        //        (dynamic)rc1.right + (dynamic)pt.x,
        //        (dynamic)rc1.bottom + (dynamic)pt.y);
        //}
        //public static ARect<T> operator -(ARect<T> rc1, APoint<T> pt)
        //{
        //    return new ARect<T>((dynamic)rc1.left - (dynamic)pt.x,
        //        (dynamic)rc1.top - (dynamic)pt.y,
        //        (dynamic)rc1.right - (dynamic)pt.x,
        //        (dynamic)rc1.bottom - (dynamic)pt.y);
        //}

        //	&= and |= operator
        public ARect<T> AndAssign(ARect<T> rc) => this & rc;
        public ARect<T> OrAssign(ARect<T> rc) => this | rc;

        public static ARect<T> operator &(ARect<T> rc1, ARect<T> rc2)
        {
            if (rc1.IsEmpty() || rc2.IsEmpty())
                return new ARect<T>(default, default, default, default);

            dynamic l1 = rc1.left, r1 = rc1.right, t1 = rc1.top, b1 = rc1.bottom;
            dynamic l2 = rc2.left, r2 = rc2.right, t2 = rc2.top, b2 = rc2.bottom;

            if (l1 >= r2 || l2 >= r1 ||
            t1 >= b2 || t2 >= b1)
                return new ARect<T>(default, default, default, default);

            return new ARect<T>(l1 > l2 ? l1 : l2,
                          t1 > t2 ? t1 : t2,
                          r1 < r2 ? r1 : r2,
                          b1 < b2 ? b1 : b2);
        }

        public static ARect<T> operator |(ARect<T> rc1, ARect<T> rc2)
        {
            if (rc1.IsEmpty())
                return rc2;

            if (rc2.IsEmpty())
                return rc1;

            dynamic l1 = rc1.left, r1 = rc1.right, t1 = rc1.top, b1 = rc1.bottom;
            dynamic l2 = rc2.left, r2 = rc2.right, t2 = rc2.top, b2 = rc2.bottom;

            return new ARect<T>(l1 < l2 ? l1 : l2,
                      t1 < t2 ? t1 : t2,
                      r1 > r2 ? r1 : r2,
                      b1 > b2 ? b1 : b2);
        }

        public static ARect<T> operator +(ARect<T> rc) { return rc; }
        public static ARect<T> operator -(ARect<T> rc)
        {
            return new ARect<T>(-(dynamic)rc.left, -(dynamic)rc.top, -(dynamic)rc.right, -(dynamic)rc.bottom);
        }

        //	= operator
        //public static ARect<T> operator = (ARect<T> rc) { left = rc.left; top = rc.top; right = rc.right; bottom = rc.bottom; return *this; }

        //	+= and -= operator
        public ARect<T> AdditionAssign(ARect<T> rc)
        {
            left += (dynamic)rc.left;
            top += (dynamic)rc.top;
            right += (dynamic)rc.right;
            bottom += (dynamic)rc.bottom;
            return this;
        }
        public ARect<T> SubtractionAssign(ARect<T> rc)
        {
            left -= (dynamic)rc.left;
            top -= (dynamic)rc.top;
            right -= (dynamic)rc.right;
            bottom -= (dynamic)rc.bottom;
            return this;
        }
        //public ARect<T> AdditionAssign(APoint<T> pt) { left += pt.x; top += pt.y; right += pt.x; bottom += pt.y; return this; }
        //public ARect<T> SubtractionAssign(APoint<T> pt) { left -= pt.x; top -= pt.y; right -= pt.x; bottom -= pt.y; return this; }

        //	Get width of rectangle
        public T Width()
        {
            return (dynamic)right - (dynamic)left;
        }
        //	Get height of rectangle
        public T Height()
        {
            return (dynamic)bottom - (dynamic)top;
        }
        //	Get center point of rectangle
        //public APoint<T> CenterPoint() { return new APoint<T>((left + right) / 2, (top + bottom) / 2); }
        //	Set rectangle value
        public void SetRect(T _left, T _top, T _right, T _bottom)
        {
            left = _left;
            top = _top;
            right = _right;
            bottom = _bottom;
        }

        //	Point in rectangle
        public bool PtInRect(T x, T y)
        {
            dynamic valueX = x;
            dynamic valueY = y;
            return (valueX >= left && valueX < right && valueY >= top && valueY < bottom) ? true : false;
        }
        //public bool PtInRect(APoint<T> pt) { return PtInRect(pt.x, pt.y); }

        //	Normalize rectangle. Note: The following CRect member functions require 
        //	normalized rectangles in order to work properly: Height, Width, Size, 
        //	IsEmpty, PtInRect, SetUnion, SetIntersect, operator ==, operator !=, 
        //	operator |, operator |=, operator &, and operator &=
        void Normalize()
        {
            if ((dynamic)left > right)
                a_Swap(left, right);

            if ((dynamic)top > bottom)
                a_Swap(top, bottom);
        }

        private void a_Swap(T lhs, T rhs)
        {
            T tmp;
            tmp = lhs;
            lhs = rhs;
            rhs = tmp;
        }

        //	All members are 0 ?
        public bool IsRectNull()
        {
            return ((dynamic)left == 0 && (dynamic)top == 0 && (dynamic)right == 0 && (dynamic)bottom == 0);
        }
        //	Rectangle is empty ?
        public bool IsEmpty()
        {
            return ((dynamic)Width() == 0 || (dynamic)Height() == 0);
        }
        //	Set all members to 0
        public void Clear()
        {
            left = top = right = bottom = default(T);
        }
        //	Deflate rectangle
        public void Deflate(T x, T y)
        {
            left += (dynamic)x;
            top += (dynamic)y;
            right -= (dynamic)x;
            bottom -= (dynamic)y;
        }
        public void Deflate(ARect<T> rc)
        {
            left += (dynamic)rc.left;
            top += (dynamic)rc.top;
            right -= (dynamic)rc.right;
            bottom -= (dynamic)rc.bottom;
        }
        public void Deflate(T l, T t, T r, T b)
        {
            left += (dynamic)l;
            top += (dynamic)t;
            right -= (dynamic)r;
            bottom -= (dynamic)b;
        }
        //	Inflate rectangle
        public void Inflate(T x, T y)
        {
            left -= (dynamic)x;
            top -= (dynamic)y;
            right += (dynamic)x;
            bottom += (dynamic)y;
        }
        public void Inflate(ARect<T> rc)
        {
            left -= (dynamic)rc.left;
            top -= (dynamic)rc.top;
            right += (dynamic)rc.right;
            bottom += (dynamic)rc.bottom;
        }
        public void Inflate(T l, T t, T r, T b)
        {
            left -= (dynamic)l;
            top -= (dynamic)t;
            right += (dynamic)r;
            bottom += (dynamic)b;
        }
        //	Offset rectangle
        public void Offset(T x, T y)
        {
            left += (dynamic)x;
            top += (dynamic)y;
            right += (dynamic)x;
            bottom += (dynamic)y;
        }
        //public void Offset(APoint<T> pt) { this += pt; }
        //	Set rectangle as union result
        public void SetUnion(ARect<T> rc1, ARect<T> rc2)
        {
            var result = rc1 | rc2;
            left = result.left;
            right = result.right;
            bottom = result.bottom;
            top = result.top;
        }
        //	Set rectangle as intersect result
        public void SetIntersect(ARect<T> rc1, ARect<T> rc2)
        {
            var result = rc1 & rc2;
            left = result.left;
            right = result.right;
            bottom = result.bottom;
            top = result.top;
        }
    }
}