using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Destruction;
using Chernobyl.Mathematics.Movement;
using UnityEngine;
using Transform = UnityEngine.Transform;

namespace Chernobyl.Unity.Math
{
    /// <summary>
    /// Extensions and utility methods for <see cref="Vector2"/>.
    /// </summary>
    public static class Vector2Ext
    {
        /// <summary>
        /// Rounds a <see cref="Vector2"/> to a <see cref="Vector2Int"/>.
        /// </summary>
        public static Vector2Int RoundToInt(this Vector2 value) =>
            new Vector2Int(Mathf.RoundToInt(value.x), Mathf.RoundToInt(value.y));
    }

    /// <summary>
    /// Extensions and utility methods for <see cref="Vector2"/>.
    /// </summary>
    public static class Vector2IntExt
    {
        /// <summary>
        /// Converts from <see cref="Vector2Int"/> to <see cref="Tuple{T1, T2}"/>.
        /// </summary>
        public static Tuple<int, int> ToTuple(this Vector2Int value) =>
            Tuple.Create(value.x, value.y);

        /// <summary>
        /// Converts from <see cref="Vector2Int"/> to a <see cref="ValueTuple{T1, T2}"/>.
        /// </summary>
        public static (int x, int y) ToValueTuple(this Vector2Int value) =>
            (value.x, value.y);

        /// <summary>
        /// Get the coordinates for the cell above <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetNorthCoordinates(this Vector2Int cell) => cell + new Vector2Int(0, 1);

        /// <summary>
        /// Get the coordinates for the cell above and to the right of <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetNorthEastCoordinates(this Vector2Int cell) => cell + new Vector2Int(1, 1);

        /// <summary>
        /// Get the coordinates for the cell to the right of <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetEastCoordinates(this Vector2Int cell) => cell + new Vector2Int(1, 0);

        /// <summary>
        /// Get the coordinates for the cell below and to the right <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetSouthEastCoordinates(this Vector2Int cell) => cell + new Vector2Int(1, -1);

        /// <summary>
        /// Get the coordinates for the cell below <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetSouthCoordinates(this Vector2Int cell) => cell + new Vector2Int(0, -1);

        /// <summary>
        /// Get the coordinates for the cell below and to the left <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetSouthWestCoordinates(this Vector2Int cell) => cell + new Vector2Int(-1, -1);

        /// <summary>
        /// Get the coordinates for the cell to the left of <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetWestCoordinates(this Vector2Int cell) => cell + new Vector2Int(-1, 0);

        /// <summary>
        /// Get the coordinates for the cell above and to the left of <paramref name="cell"/>.
        /// </summary>
        public static Vector2Int GetNorthWestCoordinates(this Vector2Int cell) => cell + new Vector2Int(-1, 1);

        /// <summary>
        /// Calculates the center of the <paramref name="cells"/>. Returns (0, 0) if
        /// <paramref name="cells"/> is empty.
        /// </summary>
        public static Vector2Int CalculateCenter(this IReadOnlyCollection<Vector2Int> cells)
        {
            Vector2Int result = Vector2Int.zero;

            if(cells.Count > 0)
            {
                var orderedByX = cells.OrderByDescending(p => p.x).ToArray();
                var orderedByY = cells.OrderByDescending(p => p.y).ToArray();

                var maxX = orderedByX[0].x;
                var minX = orderedByX[orderedByX.Length - 1].x;

                var maxY = orderedByY[0].y;
                var minY = orderedByY[orderedByY.Length - 1].y;

                var min = new Vector2(minX, minY);
                var halfDistance = new Vector2((float) (maxX - minX) / 2, (float) (maxY - minY) / 2);

                result = (min + halfDistance).RoundToInt();
            }

            return result;
        }
    }

    /// <summary>
    /// Extensions and utility methods for <see cref="Vector3"/>.
    /// </summary>
    public static class Vector3Ext
    {
        /// <summary>
        /// Rounds a <see cref="Vector3"/> to a <see cref="Vector3Int"/>.
        /// </summary>
        public static Vector3Int RoundToInt(this Vector3 value) =>
            new Vector3Int(Mathf.RoundToInt(value.x), Mathf.RoundToInt(value.y), Mathf.RoundToInt(value.z));
    }

    /// <summary>
    /// Extensions and utility methods for <see cref="Vector3Int"/>.
    /// </summary>
    public static class Vector3IntExt
    {
        /// <summary>
        /// Returns the X and Y components of the <see cref="Vector3Int"/>.
        /// </summary>
        public static Vector2Int Xy(this Vector3Int value) => new Vector2Int(value.x, value.y);
    }

    /// <summary>
    /// Extension methods for transforms.
    /// </summary>
    public static class UnityTransform
    {
        /// <summary>
        /// Binds together a Chernobyl transform with a Unity transform such that changes to the
        /// <paramref name="chernobylTransform"/> will be reflected in the <paramref name="unityTransform"/>.
        /// Disposing of the returned <see cref="IDisposable"/> will unbind the two transforms.
        /// </summary>
        /// <remarks>
        /// Remember to dispose of the returned disposable before disposing of the Unity
        /// <see cref="Transform"/> or its <see cref="GameObject"/>. Failing to do so can cause Unity
        /// to generate an exception indicating that the <see cref="Transform"/> is being modified
        /// after the <see cref="Transform"/> has been disposed of, e.g. "MissingReferenceException:
        /// The object of type 'Transform' has been destroyed but you are still trying to access it."
        /// </remarks>
        public static IDisposable Bind(this ITransform chernobylTransform, Transform unityTransform)
        {
            void OnTransformDirtied(object sender, EventArgs args)
            {
                unityTransform.localPosition = new Vector3(
                    chernobylTransform.Position.X, chernobylTransform.Position.Y,
                    unityTransform.localPosition.z);
            }

            chernobylTransform.TransformDirtied += OnTransformDirtied;

            OnTransformDirtied(chernobylTransform, EventArgs.Empty);
            return Disposable.From(() => chernobylTransform.TransformDirtied -= OnTransformDirtied);
        }
    }
}