using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ColdMint.scripts.debug;
using ColdMint.scripts.levelGraphEditor;
using ColdMint.scripts.map.dateBean;
using ColdMint.scripts.map.interfaces;
using ColdMint.scripts.map.room;
using ColdMint.scripts.utils;
using Godot;

namespace ColdMint.scripts.map.RoomPlacer;

/// <summary>
/// <para>Patchwork room placement strategy</para>
/// <para>拼接的房间放置策略</para>
/// </summary>
/// <remarks>
///<para>Under this strategy, think of each room template as a puzzle piece, find their "slots", and then connect them together.</para>
///<para>在此策略下，将每个房间模板看作是一块拼图，找到他们的“槽”，然后将其连接在一起。</para>
/// </remarks>
public class PatchworkRoomPlacementStrategy : IRoomPlacementStrategy
{
    /// <summary>
    /// <para>We use a temporary area to measure whether the rooms overlap</para>
    /// <para>我们使用一个临时区域进行测量房间是否重叠</para>
    /// </summary>
    private Area2D? _measuringArea2D;

    private CollisionShape2D? _measuringCollisionShape2D;

    private Area2D? _selfArea2D;

    /// <summary>
    /// <para>How many rooms overlap with the new rooms that will be placed</para>
    /// <para>有多少个房间与将要放置的新房间重叠</para>
    /// </summary>
    private int _overlapQuantity;

    public Task<bool> StartGeneration(Node mapRoot)
    {
        if (_measuringArea2D == null)
        {
            _measuringArea2D = new Area2D();
            _measuringArea2D.Monitoring = true;
            _measuringArea2D.AreaEntered += body =>
            {
                if (_selfArea2D != null && body == _selfArea2D)
                {
                    return;
                }

                //Room overlap detected
                //检测到房间重叠
                _overlapQuantity++;
            };
            _measuringArea2D.AreaExited += body =>
            {
                if (_selfArea2D != null && body == _selfArea2D)
                {
                    return;
                }

                //Rooms no longer overlap
                //房间不再重叠
                _overlapQuantity--;
            };
            mapRoot.AddChild(_measuringArea2D);
        }

        if (_measuringCollisionShape2D == null)
        {
            _measuringCollisionShape2D = new CollisionShape2D();
            _measuringArea2D.AddChild(_measuringCollisionShape2D);
        }

        return Task.FromResult(true);
    }

    public Task GeneratedComplete(Node mapRoot)
    {
        if (_measuringCollisionShape2D != null)
        {
            _measuringCollisionShape2D?.QueueFree();
            _measuringArea2D?.RemoveChild(_measuringCollisionShape2D);
            _measuringCollisionShape2D = null;
        }

        if (_measuringArea2D != null)
        {
            _measuringArea2D?.QueueFree();
            mapRoot.RemoveChild(_measuringArea2D);
            _measuringArea2D = null;
        }

        return Task.CompletedTask;
    }


    public Task<bool> PlaceRoom(Node mapRoot, RoomPlacementData roomPlacementData)
    {
        if (roomPlacementData.NewRoom == null || roomPlacementData.Position == null)
        {
            return Task.FromResult(false);
        }

        if (roomPlacementData.NewRoom.RootNode == null)
        {
            return Task.FromResult(false);
        }

        var newRootRootNode = roomPlacementData.NewRoom.RootNode;
        mapRoot.AddChild(newRootRootNode);
        newRootRootNode.Position = roomPlacementData.Position.Value;
        //Place navigation Link
        //放置导航Link
        Vector2? navigationLink2DStartPosition = null;
        if (roomPlacementData is { ParentRoom: not null, ParentRoomSlot: not null })
        {
            var parentRoomTileMap = roomPlacementData.ParentRoom.GetTileMapLayer(Config.TileMapLayerName.Ground);
            var parentRoomRootNode = roomPlacementData.ParentRoom.RootNode;
            if (parentRoomTileMap != null && parentRoomRootNode != null)
            {
                navigationLink2DStartPosition = parentRoomRootNode.Position +
                                                parentRoomTileMap.MapToLocal(roomPlacementData.ParentRoomSlot
                                                    .EndPosition);
            }
        }

        Vector2? navigationLink2DEndPosition = null;
        if (roomPlacementData.NewRoomSlot != null)
        {
            var newRoomTileMap = roomPlacementData.NewRoom.GetTileMapLayer(Config.TileMapLayerName.Ground);
            if (newRoomTileMap != null)
            {
                navigationLink2DEndPosition = newRootRootNode.Position +
                                              newRoomTileMap.MapToLocal(roomPlacementData.NewRoomSlot.EndPosition);
            }
        }

        if (navigationLink2DStartPosition != null && navigationLink2DEndPosition != null)
        {
            var navigationLink2D = new NavigationLink2D();
            navigationLink2D.StartPosition = navigationLink2DStartPosition.Value;
            navigationLink2D.EndPosition = navigationLink2DEndPosition.Value;
            mapRoot.AddChild(navigationLink2D);
        }

        return Task.FromResult(true);
    }

    public async Task<RoomPlacementData?> CalculateNewRoomPlacementData(RandomNumberGenerator randomNumberGenerator,
        Room? parentRoomNode,
        RoomNodeData newRoomNodeData)
    {
        if (newRoomNodeData.RoomTemplateSet == null || newRoomNodeData.RoomTemplateSet.Length == 0)
        {
            LogCat.LogWithFormat("new_room_node_data_is_incomplete", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
            return null;
        }

        if (parentRoomNode == null)
        {
            LogCat.LogWithFormat("parent_room_does_not_exist", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
            return null;
        }

        var roomResArray = RoomFactory.RoomTemplateSetToRoomRes(newRoomNodeData.RoomTemplateSet);
        if (roomResArray.Length == 0)
        {
            LogCat.LogWithFormat("room_template_does_not_exist", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
            return null;
        }

        var roomSlots = parentRoomNode.RoomSlots;
        if (roomSlots == null || roomSlots.Length == 0)
        {
            LogCat.LogWithFormat("room_slot_does_not_exist", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
            return null;
        }

        //Saves all data in the room template that matches the parent room.
        //保存房间模板内所有与父房间匹配的数据。
        var usableRoomPlacementData = new List<RoomPlacementData>();
        foreach (var roomRes in roomResArray)
        {
            var newRoom = RoomFactory.CreateRoom(roomRes, newRoomNodeData.EnterRoomEventHandlerId,
                newRoomNodeData.ExitRoomEventHandlerId);
            if (newRoom == null)
            {
                LogCat.LogWithFormat("room_corresponding_to_resource_is_null", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id, roomRes);
                continue;
            }

            //Create a room, try to use the room slot to match the existing room slot.
            //创建了一个房间，尝试使用房间的槽与现有的房间槽匹配。
            if (!IsMatch(parentRoomNode, newRoom, out var mainRoomSlot, out var newRoomSlot).Result)
            {
                LogCat.LogWithFormat("slots_do_not_match", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
                continue;
            }

            if (mainRoomSlot == null || newRoomSlot == null)
            {
                LogCat.LogWithFormat("slot_incomplete", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
                continue;
            }

            var position = await CalculatedPosition(parentRoomNode, newRoom, mainRoomSlot, newRoomSlot, false);
            if (position == null)
            {
                LogCat.LogWithFormat("placement_position_is_empty", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
                continue;
            }
            var roomPlacementData = new RoomPlacementData
            {
                NewRoom = newRoom,
                ParentRoom = parentRoomNode,
                Position = position,
                ParentRoomSlot = mainRoomSlot,
                NewRoomSlot = newRoomSlot
            };
            usableRoomPlacementData.Add(roomPlacementData);
        }

        if (usableRoomPlacementData.Count == 0)
        {
            LogCat.LogWithFormat("available_rooms_are_not_available", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy, newRoomNodeData.Id);
            return null;
        }
        else
        {
            var index = randomNumberGenerator.Randi() % usableRoomPlacementData.Count;
            var roomPlacementData = usableRoomPlacementData[(int)index];
            return roomPlacementData;
        }
    }

    public Task<RoomPlacementData?> CalculatePlacementDataForStartingRoom(RandomNumberGenerator randomNumberGenerator,
        RoomNodeData startRoomNodeData)
    {
        if (startRoomNodeData.RoomTemplateSet == null || startRoomNodeData.RoomTemplateSet.Length == 0)
        {
            return Task.FromResult<RoomPlacementData?>(null);
        }

        var roomResArray = RoomFactory.RoomTemplateSetToRoomRes(startRoomNodeData.RoomTemplateSet);
        if (roomResArray.Length == 0)
        {
            return Task.FromResult<RoomPlacementData?>(null);
        }

        var index = randomNumberGenerator.Randi() % roomResArray.Length;
        var roomPlacementData = new RoomPlacementData
        {
            NewRoom = RoomFactory.CreateRoom(roomResArray[index], startRoomNodeData.EnterRoomEventHandlerId,
                startRoomNodeData.ExitRoomEventHandlerId),
            Position = Vector2.Zero
        };
        return Task.FromResult<RoomPlacementData?>(roomPlacementData);
    }


    /// <summary>
    /// <para>if it matches</para>
    /// <para>是否匹配</para>
    /// </summary>
    /// <param name="mainRoom"></param>
    /// <param name="newRoom"></param>
    /// <param name="outMainRoomSlot"></param>
    /// <param name="outNewRoomSlot"></param>
    /// <returns></returns>
    public Task<bool> IsMatch(Room? mainRoom, Room newRoom, out RoomSlot? outMainRoomSlot, out RoomSlot? outNewRoomSlot)
    {
        if (mainRoom == null)
        {
            outNewRoomSlot = null;
            outMainRoomSlot = null;
            return Task.FromResult(false);
        }

        var roomSlots = mainRoom.RoomSlots;
        if (roomSlots == null)
        {
            outNewRoomSlot = null;
            outMainRoomSlot = null;
            return Task.FromResult(false);
        }

        var newRoomSlots = newRoom.RoomSlots;
        if (newRoomSlots == null)
        {
            outNewRoomSlot = null;
            outMainRoomSlot = null;
            return Task.FromResult(false);
        }

        foreach (var mainRoomSlot in roomSlots)
        {
            if (mainRoomSlot == null || mainRoomSlot.Matched)
            {
                //If it's already a match, it's no longer a match
                //如果已经匹配过了，就不再匹配
                continue;
            }

            foreach (var newRoomSlot in newRoomSlots)
            {
                if (newRoomSlot == null)
                {
                    continue;
                }

                if (newRoomSlot.Matched)
                {
                    //If it's already a match, it's no longer a match
                    //如果已经匹配过了，就不再匹配
                    continue;
                }

                if (mainRoomSlot.IsHorizontal != newRoomSlot.IsHorizontal)
                {
                    continue;
                }

                if (mainRoomSlot.Length != newRoomSlot.Length)
                {
                    continue;
                }

                var distanceToMidpointOfRoom = mainRoomSlot.DistanceToMidpointOfRoom;
                var newDistanceToMidpointOfRoom = newRoomSlot.DistanceToMidpointOfRoom;
                if (distanceToMidpointOfRoom == null || newDistanceToMidpointOfRoom == null)
                {
                    continue;
                }

                if (distanceToMidpointOfRoom[0] == newDistanceToMidpointOfRoom[0] &&
                    distanceToMidpointOfRoom[1] == newDistanceToMidpointOfRoom[1])
                {
                    continue;
                }

                outMainRoomSlot = mainRoomSlot;
                outNewRoomSlot = newRoomSlot;
                return Task.FromResult(true);
            }
        }

        outNewRoomSlot = null;
        outMainRoomSlot = null;
        return Task.FromResult(false);
    }

    /// <summary>
    /// <para>Calculate room position</para>
    /// <para>计算房间位置</para>
    /// </summary>
    /// <param name="mainRoom">
    ///<para>Main room</para>
    ///<para>主房间</para>
    /// </param>
    /// <param name="newRoom">
    ///<para>New room</para>
    ///<para>新房间</para>
    /// </param>
    /// <param name="mainRoomSlot">
    ///<para>Main room slot</para>
    ///<para>主房间插槽</para>
    /// </param>
    /// <param name="newRoomSlot">
    ///<para>New room slot</para>
    ///<para>新房间插槽</para>
    /// </param>
    /// <param name="roomSlotOverlap">
    ///<para>Whether room slots allow overlays</para>
    ///<para>房间插槽是否允许覆盖</para>
    /// </param>
    /// <returns></returns>
    private async Task<Vector2?> CalculatedPosition(Room mainRoom, Room newRoom, RoomSlot? mainRoomSlot,
        RoomSlot? newRoomSlot, bool roomSlotOverlap)
    {
        var mainRoomTileMapLayer = mainRoom.GetTileMapLayer(Config.TileMapLayerName.Ground);
        var newRoomTileMapLayer = newRoom.GetTileMapLayer(Config.TileMapLayerName.Ground);
        if (mainRoom.RootNode == null || newRoom.RootNode == null ||
            mainRoomTileMapLayer == null ||
            newRoomTileMapLayer == null || mainRoomSlot == null ||
            newRoomSlot == null)
        {
            LogCat.Log("parameter_inconsistency", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy);
            return null;
        }

        //Main room slot location description
        //主房间槽位置描述
        var mainOrientationDescribe = mainRoomSlot.DistanceToMidpointOfRoom;
        //New room slot location description
        //新房间槽位置描述
        var newOrientationDescribe = newRoomSlot.DistanceToMidpointOfRoom;
        if (mainOrientationDescribe == null || newOrientationDescribe == null)
        {
            //If the room slot is described as null, null is returned
            //若房间槽描述为null，那么返回null
            LogCat.Log("room_slot_position_is_empty", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy);
            return null;
        }

        var mainRoomSlotPosition = mainRoomTileMapLayer
            .MapToLocal(mainRoomSlot.StartPosition);
        var newRoomSlotPosition = newRoomTileMapLayer
            .MapToLocal(newRoomSlot.StartPosition);
        //Get the vector from the new room slot to the main room slot
        //得到从新房间槽位到主房间槽位的向量
        var newToMain = mainRoomSlotPosition - newRoomSlotPosition;
        var result = newToMain + mainRoom.RootNode.Position;
        if (!roomSlotOverlap)
        {
            //如果不允许房间槽位重叠
            //If room slot overlap is not allowed
            if (mainRoomSlot.IsHorizontal)
            {
                //Horizontal slot, offset in the Y direction.
                //水平方向槽，向Y方向偏移。
                if (newOrientationDescribe[1] == CoordinateUtils.OrientationDescribe.Up)
                {
                    result.Y += Config.CellSize;
                }
                else
                {
                    result.Y -= Config.CellSize;
                }
            }
            else
            {
                //Vertical slot, offset in the X direction.
                //垂直方向槽向X方向偏移。
                if (newOrientationDescribe[0] == CoordinateUtils.OrientationDescribe.Right)
                {
                    result.X -= Config.CellSize;
                }
                else
                {
                    result.X += Config.CellSize;
                }
            }
        }

        //Do calculations overlap with other rooms?
        //计算结果是否与其他房间重叠？
        if (newRoom.RoomCollisionShape2D != null && _measuringArea2D != null && _measuringCollisionShape2D != null)
        {
            //Ignore yourself when detecting room overlap
            //检测房间重叠时应忽略自身
            _selfArea2D = newRoom.RoomArea2D;
            _measuringArea2D.Position = result;
            _measuringCollisionShape2D.Shape = newRoom.RoomCollisionShape2D.Shape;
            //Calculate the offset of the shape.
            //计算形状的偏移量。
            _measuringCollisionShape2D.Position = newRoom.RoomCollisionShape2D.Shape.GetRect().Size / 2;
            await Task.Delay(TimeSpan.FromMilliseconds(50));
            if (_overlapQuantity > 0)
            {
                LogCat.Log("room_overlap", label: LogCat.LogLabel.PatchworkRoomPlacementStrategy);
                return null;
            }
        }
        return result;
    }
}