using System.Collections.Generic;
using Godot;

namespace Babushka.scripts.CSharp.Common.Fight;

public partial class FightWorld : Node
{
    public class World
    {
        public required List<Room> rooms;
    }

    public class Room
    {
        public required Dictionary<int, Room> paths;
        public required List<EnemyGroup> enemyGroups;
    }

    public class EnemyGroup
    {
        public required List<Enemy> enemies;
    }

    public class Enemy
    {
        public enum Type
        {
            Blob,
            BigBlob,
            Mavka,
            YourMom
        }

        public required Type type;
        public required int? health = null; // null => initialize to full health on spawn
    }

    #region AutoLoad ( Contains _EnterTree() )

    public static FightWorld Instance { get; private set; } = null!;

    public override void _EnterTree()
    {
        Instance = this;
        MyEnterTree();
    }

    #endregion
    
    public World? world = null;
    public Room? currentRoom = null;
    public EnemyGroup? inFightWith = null;

    public void MyEnterTree()
    {
        Generate();
        currentRoom = world!.rooms[0];
    }

    public void Generate()
    {
        world = new Generator().GenerateWorld();
    }

    private class Generator
    {
        public World GenerateWorld()
        {
            var world = new World
            {
                rooms = GenerateRooms()
            };
            return world;
        }

        private List<Room> GenerateRooms()
        {
            var rooms = new List<Room>();

            var roomCount = 2;

            for (var i = 0; i < roomCount; i++)
            {
                rooms.Add(GenerateDisconnectedRoom());
            }

            // Connect rooms linearly
            for (var i = 0; i < rooms.Count - 1; i++)
            {
                rooms[i].paths[0] = rooms[i + 1];
                rooms[i + 1].paths[1] = rooms[i];
            }

            return rooms;
        }

        private Room GenerateDisconnectedRoom()
        {
            var room = new Room
            {
                paths = new Dictionary<int, Room>(),
                enemyGroups = GenerateEnemyGroups()
            };
            return room;
        }

        private List<EnemyGroup> GenerateEnemyGroups()
        {
            var enemyGroups = new List<EnemyGroup>();

            var enemyGroupCount = GD.RandRange(1, 3);

            for (var i = 0; i < enemyGroupCount; i++)
            {
                enemyGroups.Add(GenerateSingleEnemyGroup());
            }

            return enemyGroups;
        }

        private EnemyGroup GenerateSingleEnemyGroup()
        {
            var enemyGroup = new EnemyGroup
            {
                enemies = []
            };

            var enemyCount = GD.RandRange(1, 3);

            for (var i = 0; i < enemyCount; i++)
            {
                enemyGroup.enemies.Add(GenerateSingleEnemy());
            }

            return enemyGroup;
        }

        private Enemy GenerateSingleEnemy()
        {
            var typeRoll = GD.RandRange(0, 99);

            var type = typeRoll switch
            {
                < 50 => Enemy.Type.Blob,
                < 75 => Enemy.Type.BigBlob,
                < 90 => Enemy.Type.Mavka,
                _ => Enemy.Type.YourMom
            };

            var enemy = new Enemy
            {
                type = type,
                health = null
            };

            return enemy;
        }
    }
}