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

namespace Escape_Room_Engine.Engine.Scripts
{
    public class Engine : MonoBehaviour
    {
        public static Engine DefaultEngine
        {
            get
            {
                if (_foundEngine == null)
                {
                    _foundEngine = FindObjectOfType<Engine>();
                }
                return _foundEngine;
            }
        }
        private static Engine _foundEngine;

        [Required] public EngineConfiguration config;
        public Material roomMaterial;

        private int NumberOfRooms => _rooms.Count;

        private readonly List<Room> _rooms = new(1);
        private GameObject _playSpaceOrigin;

        private void Start()
        {
            _playSpaceOrigin = new GameObject("Play Space Origin");
            _playSpaceOrigin.transform.SetParent(transform);
            _playSpaceOrigin.transform.localPosition = new Vector3(-config.playSpace.x / 2f, 0, -config.playSpace.y / 2f);
        }

        public void GenerateRoom()
        {
            Logger.Log("Generating room...", LogType.RoomGeneration);
            
            // get the last entrance from the newest room or create a spawn passage with no entrance door for where the player will start
            var entrance = NumberOfRooms > 0 ? _rooms.Last().exit : new Passage(new DoorModule(null, config.spawnDoor), true);
            
            var room = new Room(entrance);
            _rooms.Add(room);
            
            GenerateSpace(room, entrance); // TODO: rooms with more than one space
            
            room.InstantiateRoom(_playSpaceOrigin.transform, (_rooms.Count - 1).ToString());
        }

        private void GenerateSpace(Room room, Passage entrance)
        {
            Logger.Log("Generating space...", LogType.RoomGeneration);
            
            // create space
            var space = new Space(entrance);
            
            // add exit
            var exitDoor = new DoorModule(space, config.exitDoorTypes.RandomElement());
            if (!space.AddModuleWithRequirements(exitDoor))
                throw new Exception("Could not satisfy requirements for exit door.");
            var exit = new Passage(exitDoor);

            // add puzzles
            for (var i = 0; i < Utilities.Utilities.RandomInclusive(config.puzzleCount.x, config.puzzleCount.y); i++)
            {
                space.AddModuleWithRequirements(new PuzzleModule(space, config.puzzleTypes.RandomElement()));
            }
            
            room.AddSpace(space, exit);
        }

        public void HideOldestRoom()
        {
            if (NumberOfRooms > 0)
            {
                _rooms[NumberOfRooms - 1].roomObject.SetActive(false);
            }
        }

        // ReSharper disable once SuggestBaseTypeForParameter
        // ReSharper disable once UnusedMember.Local
        private bool IsNotEmpty(List<DoorModuleDescription> modules) => modules.Count > 0;
    }
}