using System;
using System.Collections.Generic;
using System.Linq;
using Escape_Room_Engine.Engine.Scripts.Utilities;
using UnityEngine;
using Logger = Escape_Room_Engine.Engine.Scripts.Utilities.Logger;
using LogType = Escape_Room_Engine.Engine.Scripts.Utilities.LogType;
using Object = UnityEngine.Object;

namespace Escape_Room_Engine.Engine.Scripts.Modules
{
    public enum Orientation
    {
        North = 0, East = 90, South = 180, West = 270
    }
    
    public class Module
    {
        public static HashSet<Orientation> EveryOrientation => new(new[]
        {
            Orientation.North, Orientation.East, Orientation.South, Orientation.West
        });

        /// <summary>
        /// Get the space relative (<i>SR</i>) position of this module.
        /// </summary>
        internal Vector2Int SrPosition => srDimensions.Position;
        /// <summary>
        /// Get the room relative (<i>RR</i>) position of this module.
        /// </summary>
        internal Vector2Int RrPosition => space.ToRoomRelative(SrPosition);
        internal ModuleState State { get; private set; }

        internal readonly ModuleDescription description;
        internal Orientation orientation;

        /// <summary>
        /// The space relative (<i>SR</i>) dimensions of this module.
        /// </summary>
        protected Dimensions srDimensions;

        protected GameObject moduleObject;
        protected readonly Space space;
        private GameObject _orientationObject;

        internal Module(Space space, ModuleDescription description)
        {
            this.space = space;
            this.description = description;
        }

        internal bool IsType(ModuleType type)
        {
            return description.types.Contains(type);
        }

        /// <summary>
        /// Place this module with a position relative to the room.
        /// </summary>
        /// <param name="rrPosition">The room relative (<i>RR</i>) position of this module. Must be inside the space dimensions.</param>
        /// <exception cref="Exception">If the position is not inside the space dimensions.</exception>
        internal void PlaceRoomRelative(Vector2Int rrPosition) => Place(space.ToSpaceRelative(rrPosition));
        /// <summary>
        /// Place this module with a position relative to the space it is in.
        /// </summary>
        /// <param name="srPosition">The space relative (<i>SR</i>) position of this module. Must be inside the space dimensions.</param>
        /// <exception cref="Exception">If the position is not inside the space dimensions.</exception>
        internal void Place(Vector2Int srPosition) {
            if (space != null && !srPosition.IsInsideRelative(space.rrDimensions))
            {
                throw new Exception($"Trying to place {this} at {srPosition}, which is outside space dimensions {space.rrDimensions}.");
            }
            
            srDimensions.Position = srPosition;
            
            Logger.Log($"{this} has been placed at {srPosition} (SR)", LogType.ModulePlacement);
        }

        /// <summary>
        /// Convert a position relative to this module to one relative to its space.
        /// <example>The module relative position <c>(0, 1)</c> should always be in front of the module, wherever it faces.</example>
        /// </summary>
        /// <param name="mrPosition">The module relative (<i>MR</i>) position that should be converted to a space relative (<i>SR</i>) position.</param>
        /// <returns></returns>
        internal Vector2Int ToSpaceRelative(Vector2Int mrPosition)
        {
            return srDimensions.Position + orientation switch
            {
                Orientation.North => mrPosition,
                Orientation.East => new Vector2Int(mrPosition.y, -mrPosition.x),
                Orientation.South => -mrPosition,
                Orientation.West => new Vector2Int(-mrPosition.y, mrPosition.x),
                _ => throw new ArgumentOutOfRangeException()
            };
        }

        internal virtual void InstantiateModule(Transform parent)
        {
            moduleObject = new GameObject(ToString());
            moduleObject.transform.SetParent(parent, false);
            moduleObject.transform.localPosition = new Vector3(srDimensions.x + .5f, 0, srDimensions.z + .5f);
            AddStateComponent();
            
            _orientationObject = new GameObject("Orientation");
            _orientationObject.transform.SetParent(moduleObject.transform, false);
            _orientationObject.transform.Rotate(Vector3.up, (float)orientation);
            
            Object.Instantiate(description.modulePrefab, _orientationObject.transform, false);
        }

        protected virtual void AddStateComponent()
        {
            State = moduleObject.AddComponent<ModuleState>();
            State.SetModule(this);
        }

        public override string ToString()
        {
            return $"Module ({string.Join(", ", description.types.ToList().ConvertAll(type => type.ToString()))})";
        }
    }
}