#if UNITY_EDITOR
using System;
using System.Collections.Generic;
using UnityEngine;
using DungeonMapGenerator;
using DungeonMapGenerator.Rooms;
using Unity.VisualScripting;
using UnityEditor;
using Object = UnityEngine.Object;


namespace DungeonGenerator
{
    public class DungeonMapLoader
    {
        private const string ROOMS_PARENT = "RoomsParent";
        private const string MONSTER_ROOM = "Rooms\\MonsterRoom";
        private const string BOSS_ROOM = "Rooms\\BossRoom";
        private const string NORMAL_ROOM = "Rooms\\Room";

        
        private Dictionary<int, GameObject> _roomIdToGameObject = new Dictionary<int, GameObject>();

        public void AddDungeonRoomsToGameObject(GameObject gameObject, string pathToDungeonFile)
        {
            DungeonMap map = DungeonMapSerializer.DeserializeFromFile(pathToDungeonFile);
            GameObject bossRoomPrefab = Resources.Load<GameObject>(BOSS_ROOM);
            GameObject monsterRoomPrefab = Resources.Load<GameObject>(MONSTER_ROOM);
            GameObject normalRoomPrefab = Resources.Load<GameObject>(NORMAL_ROOM);

            Dictionary<GameObject, DungeonMapGenerator.Rooms.Room> gameObjectRoomPairs = new Dictionary<GameObject, DungeonMapGenerator.Rooms.Room>();
            
            GameObject bossRoomGO = PrefabUtility.InstantiatePrefab(bossRoomPrefab, gameObject.transform) as GameObject;
            bossRoomGO.transform.position = ConvertToUnityPosition(map.GetBossRoom().GetCenterOfRoom(), map.Width, map.Height);
            BossRoom bossRoom = map.GetBossRoom();
            gameObjectRoomPairs[bossRoomGO] = bossRoom;
            AddLockToRoomObject(bossRoomGO, bossRoom.Lock.GetLock());
            foreach (DungeonMapGenerator.Lock extraLock in bossRoom.ExtraLocks)
            {
                AddLockToRoomObject(bossRoomGO, extraLock.GetLock());
            }
            AddRewardsToRoomObject(bossRoomGO, bossRoom.GetLoot());
            _roomIdToGameObject[bossRoom.Id] = bossRoomGO;
            
            foreach (var monsterRoom in map.GetMonsterRooms())
            {
                GameObject monsterRoomGO = PrefabUtility.InstantiatePrefab(monsterRoomPrefab, gameObject.transform) as GameObject;
                monsterRoomGO.transform.position = ConvertToUnityPosition(monsterRoom.GetCenterOfRoom(), map.Width, map.Height);
                gameObjectRoomPairs[monsterRoomGO] = monsterRoom;
                AddLockToRoomObject(monsterRoomGO, monsterRoom.Lock.GetLock());
                foreach (DungeonMapGenerator.Lock extraLock in monsterRoom.ExtraLocks)
                {
                    AddLockToRoomObject(monsterRoomGO, extraLock.GetLock());
                }
                AddRewardsToRoomObject(monsterRoomGO, monsterRoom.GetLoot());
                _roomIdToGameObject[monsterRoom.Id] = monsterRoomGO;
            }

            foreach (var normalRoom in map.GetNormalRooms())
            {
                GameObject normalRoomGO = PrefabUtility.InstantiatePrefab(normalRoomPrefab, gameObject.transform) as GameObject;
                normalRoomGO.transform.position = ConvertToUnityPosition(normalRoom.GetCenterOfRoom(), map.Width, map.Height);
                gameObjectRoomPairs[normalRoomGO] = normalRoom;
                AddLockToRoomObject(normalRoomGO, normalRoom.Lock.GetLock());
                AddRewardsToRoomObject(normalRoomGO, normalRoom.GetLoot());
                _roomIdToGameObject[normalRoom.Id] = normalRoomGO;
            }

            foreach (var entranceRoom in map.GetEntranceRooms())
            {
                GameObject entranceRoomGO = PrefabUtility.InstantiatePrefab(normalRoomPrefab, gameObject.transform) as GameObject;
                entranceRoomGO.transform.position = ConvertToUnityPosition(entranceRoom.GetCenterOfRoom(), map.Width, map.Height);
                gameObjectRoomPairs[entranceRoomGO] = entranceRoom;
                entranceRoomGO.GetComponent<Room>().IsEntrance = true;
                AddLockToRoomObject(entranceRoomGO, entranceRoom.Lock.GetLock());
                AddRewardsToRoomObject(entranceRoomGO, entranceRoom.GetLoot());
                _roomIdToGameObject[entranceRoom.Id] = entranceRoomGO;
            }

            foreach (var mapRoom in map.GetAllRooms())
            {
                HashSet<int> adjacentRoomsIds = mapRoom.GetAdjacentRoomIds();
                Room roomComponent = _roomIdToGameObject[mapRoom.Id].GetComponent<Room>();
                foreach (var id in adjacentRoomsIds)
                {
                    roomComponent.AdjacentRooms.Add(_roomIdToGameObject[id]);
                }
            }

            foreach (var kvp in gameObjectRoomPairs)
            {
                if (kvp.Value.GetType() == typeof(DungeonMapGenerator.Rooms.MonsterRoom) || kvp.Value.GetType() == typeof(DungeonMapGenerator.Rooms.BossRoom))
                {
                    AddBlockingRooms(kvp.Key.GetComponent<Room>(), (DungeonMapGenerator.Rooms.MonsterRoom)kvp.Value);
                }
            }
        }

        private Vector3 ConvertToUnityPosition(Point dungeonPosition, int mapWidth, int mapHeight)
        {
            float newX = (dungeonPosition.X - (mapWidth / 2f)) / 2;
            float newY = -(dungeonPosition.Y - (mapHeight / 2f)) / 2;

            return new Vector3(newX, newY, 0f);
        }

        private void AddLockToRoomObject(GameObject room, string lockString)
        {
            NumberLock _lock;
            switch (lockString)
            {
                case "2":
                case "3":
                case "4":
                case "5":
                case "6":
                case "7":
                case "8":
                case "9":
                case "10":
                case "11":
                case "12":
                    _lock = room.AddComponent<NumberLock>();
                    _lock.SetNumber(Int32.Parse(lockString));
                    break;
                case "=":
                    room.AddComponent<MatchingDiceLock>();
                    break;
                case null:
                    Debug.Log("Lock for room was null when imported. Using 1 as lock");
                    _lock = room.AddComponent<NumberLock>();
                    _lock.SetNumber(1);
                    break;
            }
        }

        private void AddRewardsToRoomObject(GameObject roomGO, List<LootType> loot)
        {
            RoomRewards rewards = roomGO.GetComponent<RoomRewards>();
            foreach (LootType type in loot)
            {
                switch (type)
                {
                    case LootType.Chest:
                        rewards.Chest = true;
                        break;
                    case LootType.Diamond:
                        rewards.Diamonds++;
                        break;
                    case LootType.Damage:
                        rewards.Damage++;
                        break;
                }
            }
        }

        private void AddBlockingRooms(Room roomComponent, DungeonMapGenerator.Rooms.MonsterRoom room)
        {
            foreach (var blockingRoomId in room.GetBlockingRoomIds())
            {
                roomComponent.AddBlockingRoom(_roomIdToGameObject[blockingRoomId].GetComponent<Room>());
                
            }
        }
    }
}
#endif