Random Dungeon

using System;
using System.Collections.Generic;
using Yukar.Engine;
using System.IO;
using System.Linq;
using Microsoft.Xna.Framework;

namespace Bakin
{
    public static class DungeonConstants
    {
        public const int DEFAULT_FLOOR = 4;
        public const int DEFAULT_WALL = 5;
        public const int DEFAULT_CORRIDOR = 6;
        public const int FLOOR_HEIGHT = 1;
        public const int WALL_HEIGHT = 10;
        public const int CORRIDOR_HEIGHT = 1;
    }

    public class RandomDungeon : BakinObject
    {
        private MapScene mapScene;
        private DungeonData currentDungeon;
        private const string SAVE_DIRECTORY = "SavedDungeons";
        private const string FILE_EXTENSION = ".dungeon";
        private List<MapCharacter> usedEvents = new List<MapCharacter>();

        public override void Start()
        {
            mapScene = GameMain.instance.mapScene;

            if (GameMain.instance.getScenes() == GameMain.Scenes.TITLE ||
                GameMain.instance.getScenes() == GameMain.Scenes.LOADING ||
                mapScene == null)
                return;

            Directory.CreateDirectory(SAVE_DIRECTORY);
        }

        [BakinFunction(Description = "1) Generate basic dungeon (23x23)")]
        public void Generate()
        {
            GenerateNewDungeon(23, 23, 4, 8, 5,
                DungeonConstants.DEFAULT_FLOOR,
                DungeonConstants.DEFAULT_WALL,
                DungeonConstants.DEFAULT_CORRIDOR);
        }

        [BakinFunction(Description = "2) Save current dungeon")]
        public void Save(string dungeonName)
        {
            SaveDungeon(dungeonName);
        }

        [BakinFunction(Description = "3) Load saved dungeon")]
        public void Load(string dungeonName)
        {
            LoadDungeon(dungeonName);
        }

        [BakinFunction(Description = "4) Generate custom size dungeon (width_height)")]
        public void GenerateCustomSize(string size)
        {
            string[] dimensions = size.Split('_');
            if (dimensions.Length == 2 && int.TryParse(dimensions[0], out int width) && int.TryParse(dimensions[1], out int height))
            {
                GenerateNewDungeon(width, height, 3, 6, 100,
                    DungeonConstants.DEFAULT_FLOOR,
                    DungeonConstants.DEFAULT_WALL,
                    DungeonConstants.DEFAULT_CORRIDOR);
            }
        }

        [BakinFunction(Description = "5) Generate with custom terrain (floor_wall_corridor)")]
        public void GenerateCustomTerrain(string terrainTypes)
        {
            string[] types = terrainTypes.Split('_');
            if (types.Length == 3 && int.TryParse(types[0], out int floor) &&
                int.TryParse(types[1], out int wall) && int.TryParse(types[2], out int corridor))
            {
                GenerateNewDungeon(23, 23, 3, 6, 100, floor, wall, corridor);
            }
        }

        [BakinFunction(Description = "0) Clear/Reset current dungeon")]
        public void Clear()
        {
            if (mapScene?.mapDrawer == null) return;

            int width = currentDungeon != null ? currentDungeon.Width : 23;
            int height = currentDungeon != null ? currentDungeon.Height : 23;

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    mapScene.mapDrawer.setTerrain(x, y, 1, 1, true);
                }
            }
            mapScene.mapDrawer.updateMapHeightAndWalkableState(true);
            currentDungeon = null;
        }

        private void GenerateNewDungeon(int width, int height, int minRoomSize, int maxRoomSize, int maxRooms,
            int floorType, int wallType, int corridorType)
        {
            currentDungeon = new DungeonData(width, height)
            {
                FloorType = floorType,
                WallType = wallType,
                CorridorType = corridorType
            };

            for (int x = 0; x < width; x++)
            {
                for (int y = 0; y < height; y++)
                {
                    currentDungeon.TerrainData[x, y] = wallType;
                }
            }

            GenerateRooms(minRoomSize, maxRoomSize, maxRooms);
        }

        private void SaveDungeon(string saveName)
        {
            if (currentDungeon == null) return;

            string filePath = Path.Combine(SAVE_DIRECTORY, saveName + FILE_EXTENSION);
            string data = SerializeDungeon(currentDungeon);
            File.WriteAllText(filePath, data);
        }

        private void LoadDungeon(string saveName)
        {
            string filePath = Path.Combine(SAVE_DIRECTORY, saveName + FILE_EXTENSION);
            if (!File.Exists(filePath)) return;

            string data = File.ReadAllText(filePath);
            currentDungeon = DeserializeDungeon(data);

            // Find all rooms in the loaded dungeon
            List<Room> rooms = FindRoomsInLoadedDungeon();

            ApplyDungeonToMap();
            PlacePlayerInRandomRoom(rooms); // Place player in a random room after loading
        }

        private List<Room> FindRoomsInLoadedDungeon()
        {
            List<Room> rooms = new List<Room>();
            if (currentDungeon == null) return rooms;

            // Scan the dungeon for rooms by looking for floor tiles surrounded by walls
            for (int x = 1; x < currentDungeon.Width - 1; x++)
            {
                for (int y = 1; y < currentDungeon.Height - 1; y++)
                {
                    if (currentDungeon.TerrainData[x, y] == currentDungeon.FloorType)
                    {
                        Room room = ExpandRoom(x, y);
                        if (room != null)
                        {
                            rooms.Add(room);
                            // Skip the tiles we just processed
                            y += room.Height;
                        }
                    }
                }
            }

            return rooms;
        }

        private Room ExpandRoom(int startX, int startY)
        {
            if (currentDungeon.TerrainData[startX, startY] != currentDungeon.FloorType) return null;

            int width = 0, height = 0;

            // Find width
            for (int x = startX; x < currentDungeon.Width - 1; x++)
            {
                if (currentDungeon.TerrainData[x, startY] != currentDungeon.FloorType) break;
                width++;
            }

            // Find height
            for (int y = startY; y < currentDungeon.Height - 1; y++)
            {
                if (currentDungeon.TerrainData[startX, y] != currentDungeon.FloorType) break;
                height++;
            }

            // Verify it's a proper room (has walls around it)
            if (width < 2 || height < 2) return null;

            return new Room(startX, startY, width, height);
        }

        private string SerializeDungeon(DungeonData dungeon)
        {
            List<string> lines = new List<string>
            {
                $"Width:{dungeon.Width}",
                $"Height:{dungeon.Height}",
                $"Floor:{dungeon.FloorType}",
                $"Wall:{dungeon.WallType}",
                $"Corridor:{dungeon.CorridorType}"
            };

            // Save terrain data
            for (int y = 0; y < dungeon.Height; y++)
            {
                string row = "";
                for (int x = 0; x < dungeon.Width; x++)
                {
                    row += dungeon.TerrainData[x, y].ToString();
                    if (x < dungeon.Width - 1) row += ",";
                }
                lines.Add(row);
            }

            // Save event positions
            lines.Add("Events:");
            var moveEvents = mapScene.mapCharList
                .Where(chr => chr != mapScene.hero && chr.rom?.name?.Contains("Move") == true);

            foreach (var evt in moveEvents)
            {
                Vector3 pos = evt.getPosition();
                lines.Add($"{evt.rom.name}:{pos.X},{pos.Y},{pos.Z}");
            }

            return string.Join("\n", lines);
        }

        private DungeonData DeserializeDungeon(string data)
        {
            string[] lines = data.Split('\n');
            int width = int.Parse(lines[0].Split(':')[1]);
            int height = int.Parse(lines[1].Split(':')[1]);

            DungeonData dungeon = new DungeonData(width, height);
            dungeon.FloorType = int.Parse(lines[2].Split(':')[1]);
            dungeon.WallType = int.Parse(lines[3].Split(':')[1]);
            dungeon.CorridorType = int.Parse(lines[4].Split(':')[1]);

            // Load terrain data
            int currentLine = 5;
            for (int y = 0; y < height; y++)
            {
                string[] values = lines[currentLine + y].Split(',');
                for (int x = 0; x < width; x++)
                {
                    dungeon.TerrainData[x, y] = int.Parse(values[x]);
                }
            }

            // Load event positions
            currentLine += height;
            if (currentLine < lines.Length && lines[currentLine] == "Events:")
            {
                currentLine++;
                while (currentLine < lines.Length)
                {
                    string[] eventData = lines[currentLine].Split(':');
                    string eventName = eventData[0];
                    string[] position = eventData[1].Split(',');

                    var evt = mapScene.mapCharList.FirstOrDefault(chr =>
                        chr != mapScene.hero &&
                        chr.rom?.name == eventName);

                    if (evt != null)
                    {
                        float x = float.Parse(position[0]);
                        float y = float.Parse(position[1]);
                        float z = float.Parse(position[2]);
                        evt.setPosition(new Vector3(x, y, z));
                    }

                    currentLine++;
                }
            }

            return dungeon;
        }

        private Dictionary<int, string> GetAvailableTerrains()
        {
            Dictionary<int, string> terrains = new Dictionary<int, string>();
            Dictionary<int, Guid> chipList = mapScene.map.getChipList();

            foreach (KeyValuePair<int, Guid> chip in chipList)
            {
                var mapChip = catalog.getItemFromGuid<Yukar.Common.Resource.MapChip>(chip.Value);
                terrains.Add(chip.Key, mapChip?.Name ?? "unknown");
            }

            return terrains;
        }

        private void ApplyDungeonToMap()
        {
            if (mapScene?.mapDrawer == null || currentDungeon == null) return;

            Dictionary<int, Guid> availableTerrains = mapScene.map.getChipList();

            for (int x = 0; x < currentDungeon.Width; x++)
            {
                for (int y = 0; y < currentDungeon.Height; y++)
                {
                    int currentTile = currentDungeon.TerrainData[x, y];
                    int terrainId;
                    int height;

                    if (currentTile == currentDungeon.WallType)
                    {
                        terrainId = currentDungeon.WallType;
                        height = DungeonConstants.WALL_HEIGHT;
                    }
                    else if (currentTile == currentDungeon.FloorType)
                    {
                        terrainId = currentDungeon.FloorType;
                        height = DungeonConstants.FLOOR_HEIGHT;
                    }
                    else // Corridor
                    {
                        terrainId = currentDungeon.CorridorType;
                        height = DungeonConstants.CORRIDOR_HEIGHT;
                    }

                    mapScene.mapDrawer.setTerrain(x, y, height, terrainId, true);
                    mapScene.mapDrawer.setTerrainAttr(x, y, terrainId, Yukar.Common.Rom.Map.AttribDir.All, true);
                }
            }

            mapScene.mapDrawer.updateMapHeightAndWalkableState(true);
        }

        [BakinFunction(Description = "Show available terrain types")]
        public void ShowTerrains()
        {
            Dictionary<int, Guid> terrains = mapScene.map.getChipList();
            System.Text.StringBuilder sb = new System.Text.StringBuilder();
            sb.AppendLine("Available Terrain Types for this map:");
            sb.AppendLine();

            foreach (var terrain in terrains)
            {
                var mapChip = catalog.getItemFromGuid<Yukar.Common.Resource.MapChip>(terrain.Value);
                sb.AppendLine($"ID: {terrain.Key} - {mapChip?.Name ?? "unknown"}");
            }

            mapScene.spManager.ShowText(0, sb.ToString(), 0, 0);
        }

        private void GenerateRooms(int minRoomSize, int maxRoomSize, int maxRooms)
        {
            List<Room> rooms = new List<Room>();
            Random random = new Random();

            // Get all "Move" events at the start
            var moveEvents = mapScene.mapCharList
                .Where(chr => chr != mapScene.hero && chr.rom?.name?.Contains("Move") == true)
                .ToList();

            int attempts = 0;
            while (rooms.Count < maxRooms && attempts < 1000)
            {
                int roomWidth = random.Next(minRoomSize, maxRoomSize + 1);
                int roomHeight = random.Next(minRoomSize, maxRoomSize + 1);
                int roomX = random.Next(2, currentDungeon.Width - roomWidth - 2);
                int roomY = random.Next(2, currentDungeon.Height - roomHeight - 2);

                Room newRoom = new Room(roomX, roomY, roomWidth, roomHeight);

                bool tooClose = rooms.Exists(r =>
                    Math.Abs(r.CenterX - newRoom.CenterX) < roomWidth + 2 ||
                    Math.Abs(r.CenterY - newRoom.CenterY) < roomHeight + 2);

                if (!tooClose)
                {
                    rooms.Add(newRoom);
                    // Create the room
                    for (int x = roomX - 1; x <= roomX + roomWidth; x++)
                    {
                        for (int y = roomY - 1; y <= roomY + roomHeight; y++)
                        {
                            if (x == roomX - 1 || x == roomX + roomWidth ||
                                y == roomY - 1 || y == roomY + roomHeight)
                            {
                                currentDungeon.TerrainData[x, y] = currentDungeon.WallType;
                            }
                            else
                            {
                                currentDungeon.TerrainData[x, y] = currentDungeon.FloorType;
                            }
                        }
                    }
                }
                attempts++;
            }

            // Place all "Move" events in random rooms
            foreach (var moveEvent in moveEvents)
            {
                if (rooms.Count == 0) break;

                // Pick a random room
                Room randomRoom = rooms[random.Next(rooms.Count)];

                // Calculate random position within the room (avoiding walls)
                int eventX = random.Next(randomRoom.X + 1, randomRoom.X + randomRoom.Width - 1);
                int eventY = random.Next(randomRoom.Y + 1, randomRoom.Y + randomRoom.Height - 1);

                // Move the event to the new position, setting Y to 0.5f to match player height
                Vector3 newPosition = new Vector3(eventX + 0.5f, 0.25f, eventY + 0.5f);
                moveEvent.setPosition(newPosition);
            }

            ConnectRooms(rooms);
            ApplyDungeonToMap();
            PlacePlayerInRandomRoom(rooms);
        }

        private void ConnectRooms(List<Room> rooms)
        {
            for (int i = 1; i < rooms.Count; i++)
            {
                int prevRoomCenterX = Clamp(rooms[i - 1].CenterX, 1, currentDungeon.Width - 2);
                int prevRoomCenterY = Clamp(rooms[i - 1].CenterY, 1, currentDungeon.Height - 2);
                int currRoomCenterX = Clamp(rooms[i].CenterX, 1, currentDungeon.Width - 2);
                int currRoomCenterY = Clamp(rooms[i].CenterY, 1, currentDungeon.Height - 2);

                CreateCorridor(prevRoomCenterX, prevRoomCenterY, currRoomCenterX, currRoomCenterY);
            }
        }

        private void CreateCorridor(int fromX, int fromY, int toX, int toY)
        {
            int currentX = fromX;
            int currentY = fromY;

            bool horizontalFirst = new Random().Next(2) == 0;

            if (horizontalFirst)
            {
                while (currentX != toX)
                {
                    currentX += Math.Sign(toX - currentX);
                    CreateCorridorTile(currentX, currentY);
                }
                while (currentY != toY)
                {
                    currentY += Math.Sign(toY - currentY);
                    CreateCorridorTile(currentX, currentY);
                }
            }
            else
            {
                while (currentY != toY)
                {
                    currentY += Math.Sign(toY - currentY);
                    CreateCorridorTile(currentX, currentY);
                }
                while (currentX != toX)
                {
                    currentX += Math.Sign(toX - currentX);
                    CreateCorridorTile(currentX, currentY);
                }
            }
        }

        private void CreateCorridorTile(int x, int y)
        {
            if (x > 0 && x < currentDungeon.Width - 1 && y > 0 && y < currentDungeon.Height - 1)
            {
                currentDungeon.TerrainData[x, y] = currentDungeon.CorridorType;

                if (currentDungeon.TerrainData[x - 1, y] == currentDungeon.WallType)
                    currentDungeon.TerrainData[x - 1, y] = currentDungeon.WallType;
                if (currentDungeon.TerrainData[x + 1, y] == currentDungeon.WallType)
                    currentDungeon.TerrainData[x + 1, y] = currentDungeon.WallType;
                if (currentDungeon.TerrainData[x, y - 1] == currentDungeon.WallType)
                    currentDungeon.TerrainData[x, y - 1] = currentDungeon.WallType;
                if (currentDungeon.TerrainData[x, y + 1] == currentDungeon.WallType)
                    currentDungeon.TerrainData[x, y + 1] = currentDungeon.WallType;
            }
        }

        private int Clamp(int value, int min, int max)
        {
            return (value < min) ? min : (value > max) ? max : value;
        }

        private void PlacePlayerInRandomRoom(List<Room> rooms)
        {
            if (rooms.Count == 0 || mapScene?.hero == null) return;

            // Pick a random room
            Random random = new Random();
            Room randomRoom = rooms[random.Next(rooms.Count)];

            // Calculate random position within the room (avoiding walls)
            int playerX = random.Next(randomRoom.X + 1, randomRoom.X + randomRoom.Width - 1);
            int playerY = random.Next(randomRoom.Y + 1, randomRoom.Y + randomRoom.Height - 1);

            // Move the player to the new position
            Vector3 newPosition = new Vector3(playerX + 0.5f, 0, playerY + 0.5f);
            mapScene.hero.setPosition(newPosition);
        }
    }

    [Serializable]
    public class DungeonData
    {
        public int Width { get; set; }
        public int Height { get; set; }
        public int[,] TerrainData { get; set; }
        public int FloorType { get; set; }
        public int WallType { get; set; }
        public int CorridorType { get; set; }

        public DungeonData(int width, int height)
        {
            Width = width;
            Height = height;
            TerrainData = new int[width, height];
            FloorType = DungeonConstants.DEFAULT_FLOOR;
            WallType = DungeonConstants.DEFAULT_WALL;
            CorridorType = DungeonConstants.DEFAULT_CORRIDOR;
        }
    }

    public class Room
    {
        public int X, Y, Width, Height;

        public Room(int x, int y, int width, int height)
        {
            X = x;
            Y = y;
            Width = width;
            Height = height;
        }

        public int CenterX => X + Width / 2;
        public int CenterY => Y + Height / 2;

        public bool Intersects(Room other)
        {
            return X <= other.X + other.Width &&
                   X + Width >= other.X &&
                   Y <= other.Y + other.Height &&
                   Y + Height >= other.Y;
        }
    }
}