VORTEX-REC-LEAK/Controllers/Api/PlayerEventsController.cs

using DeluxeBackend.Controllers.Matchmaking;
using DeluxeBackend.Models;
using DeluxeBackend.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.ComponentModel.DataAnnotations;
using static DeluxeBackend.Controllers.Api.AvatarController;
using static DeluxeBackend.Controllers.RoomsController;
using static DeluxeBackend.Enums;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace DeluxeBackend.Controllers.Api
{
    [Route("api/playerevents")]
    [ApiController]
    public class PlayerEventsController(IJwtService jwt, ILiteDbService db, ICdnService cdn, INotificationService ws, DiscordBotService discord) : ControllerBase
    {
        [HttpGet("v1/all")]
        public async Task<IActionResult> All()
        {
            return Ok(new { Created = new List<object>(), Responses = new List<object>() });
        }

        [Token(Token = "0x2000F45")]
        public enum DNPDKMHJGAO
        {
            [Token(Token = "0x4003C04")]
            Success,
            [Token(Token = "0x4003C05")]
            HasModeratorClosedEvent,
            [Token(Token = "0x4003C06")]
            DoesNotExist,
            [Token(Token = "0x4003C07")]
            PlayerDoesNotExist,
            [Token(Token = "0x4003C08")]
            RoomDoesNotExist,
            [Token(Token = "0x4003C09")]
            StatusUnchanged,
            [Token(Token = "0x4003C0A")]
            PrivateEvent,
            [Token(Token = "0x4003C0B")]
            SomethingWentWrong,
            [Token(Token = "0x4003C0C")]
            DoesNotOwnRoom,
            [Token(Token = "0x4003C0D")]
            ResponseDoesNotExist,
            [Token(Token = "0x4003C0E")]
            PlayerAlreadyInvited,
            [Token(Token = "0x4003C0F")]
            EventDatesInvalid,
            [Token(Token = "0x4003C10")]
            EventTooLong,
            [Token(Token = "0x4003C11")]
            EventTooShort,
            [Token(Token = "0x4003C12")]
            InappropriateName,
            [Token(Token = "0x4003C13")]
            InappropriateDescription,
            [Token(Token = "0x4003C14")]
            SomeInvitesFailed,
            [Token(Token = "0x4003C15")]
            CannotInviteJunior,
            [Token(Token = "0x4003C16")]
            EventCountLimitReached,
            [Token(Token = "0x4003C17")]
            DoesNotOwnEvent,
            [Token(Token = "0x4003C18")]
            UnregisteredOrJuniorNotAllowed,
            [Token(Token = "0x4003C19")]
            InvalidClubPermissions,
            [Token(Token = "0x4003C1A")]
            ImageDoesNotExist,
            [Token(Token = "0x4003C1B")]
            SubRoomDoesNotExist,
            [Token(Token = "0x4003C1C")]
            DoesNotOwnSubRoom,
            [Token(Token = "0x4003C1D")]
            ModifyTagsFailed,
            [Token(Token = "0x4003C1E")]
            RoomCapacityTooLow,
            [Token(Token = "0x4003C1F")]
            BroadcastEventNotMultiInstance,
            [Token(Token = "0x4003C20")]
            PlayerNotAllowedToCreateMultiInstanceEvents,
            [Token(Token = "0x4003C21")]
            PlayerBannedFromEventCreation,
            [Token(Token = "0x4003C22")]
            EventIsModerationClosed,
            [Token(Token = "0x4003C23")]
            EventIsModerationPendingReview
        }

        [HttpGet("v1/tagfilters")]
        public async Task<IActionResult> Tagfilters()
        {
            return Ok(new
            {
                PinnedFilters = new[]
                {
                    "workshops",
                    "celebration",
                    "game",
                    "meetup",
                    "performance",
                    "coop",
                    "grandopening",
                    "class",
                    "competition"
                },
                PopularFilters = new[]
                {
                    "workshops",
                    "celebration",
                    "class",
                    "coop",
                    "competition",
                    "game",
                    "grandopening",
                    "meetup",
                    "performance"
                },
                TrendingFilters = (string[]?)null
            });
        }

        public class CreateEventRequest
        {
            public RoomAccessibility Accessibility { get; set; }
            public BroadcastPerms CanRequestBroadcastPermissions { get; set; } = BroadcastPerms.None;
            public int? ClubId { get; set; }
            public BroadcastPerms DefaultBroadcastPermissions { get; set; } = BroadcastPerms.None;
            public string Description { get; set; } = string.Empty;
            public DateTime EndTime { get; set; }
            public string? ImageName { get; set; }
            public bool IsMultiInstance { get; set; } = false;
            public string Name { get; set; } = string.Empty;
            public int RoomId { get; set; }
            public DateTime StartTime { get; set; }
            public int? SubRoomId { get; set; }
            public bool SupportMultiInstanceRoomChat { get; set; } = false;
            public List<string> Tags { get; set; } = new();
        }

        [HttpPost("v2")]
        public async Task<IActionResult> V2([FromBody] CreateEventRequest request)
        {
            LoginWithInfoResult? login = await jwt.GetLoginWithInfo(User);

            if (login == null) return Unauthorized();
            Account account = login.Account;
            /*if (request.IsMultiInstance && !account.HasRoleAsync(discord, "").Result)
            {
                //return Ok(new { Result = DNPDKMHJGAO.PlayerNotAllowedToCreateMultiInstanceEvents });
                request.IsMultiInstance = false;
            }*/

            Room? room = db.Rooms.Include(x => x.Creator).FindOne(x => x.Id == request.RoomId);
            if (room == null)
            {
                return Ok(new { Result = DNPDKMHJGAO.RoomDoesNotExist });
            }

            if (room.Accessibility == RoomAccessibility.Private)
            {
                if (!room.HasRole(account.Id, RoomRoleType.CoOwner))
                {
                    return Ok(new { Result = DNPDKMHJGAO.DoesNotOwnRoom });
                }
            }

            List<SubRoom> subRooms = db.SubRooms.Include(x => x.Room).Find(x => x.Room.Id == room.Id && x.CanMatchmakeInto).ToList();
            if (subRooms.Count == 0)
            {
                return Ok(new { Result = DNPDKMHJGAO.SubRoomDoesNotExist });
            }

            SubRoom subRoom = subRooms[Random.Shared.Next(subRooms.Count)];


            PlayerEvent playerEvent = new()
            {
                Creator = account,
                Room = room,
                SubRoom = subRoom,
                Name = request.Name,
                Description=request.Description,
                ImageName=request.ImageName ?? "",
                StartTime=request.StartTime,
                EndTime=request.EndTime,
                Accessibility=request.Accessibility,
                IsMultiInstance=request.IsMultiInstance,
                SupportMultiInstanceRoomChat=request.SupportMultiInstanceRoomChat,
                DefaultBroadcastPermissions=request.DefaultBroadcastPermissions,
                CanRequestBroadcastPermissions=request.CanRequestBroadcastPermissions
            };
            db.PlayerEvents.Insert(playerEvent);
            /*AccountPresence presence = GetOrCreatePresence(account);
            RoomInstance roomInstance = CreateNewInstance(subRoom, Enums.RoomInstanceType.MultiInstanceEvent, true, playerEvent.Id);
            playerEvent.BroadcastingRoomInstanceId = roomInstance.Id;
            db.PlayerEvents.Update(playerEvent);
            presence.Instance = roomInstance;
            await SaveAndNotifyPresenceAsync(presence);*/

            return Ok(new { Result = DNPDKMHJGAO.Success, PlayerEvent=playerEvent.ToDictionary()});
        }


        [HttpGet("v1/{eventId}")]
        public async Task<IActionResult> GetEvent(long eventId)
        {
            PlayerEvent? playerEvent = db.PlayerEvents.Include(x => x.Room).Include(x => x.SubRoom).Include(x => x.Creator).FindById(eventId);
            if (playerEvent == null)
            {
                return NotFound();
            }
            return Ok(playerEvent.ToDictionary());
        }
        [HttpGet("v1/{eventId}/responses")]
        public async Task<IActionResult> GetEventResponses(long eventId)
        {
            PlayerEvent? playerEvent = db.PlayerEvents.Include(x => x.Room).Include(x => x.SubRoom).Include(x => x.Creator).FindById(eventId);
            if (playerEvent == null)
            {
                return NotFound();
            }
            return Ok(new List<object>());
        }

        public class BroadcastRequest
        {
            public required long PlayerEventId { get; set; }
            public required long BroadcastRoomInstanceId { get; set; }
        }

        [HttpPost("v1/broadcast")]
        public async Task<IActionResult> Broadcast([FromBody] BroadcastRequest request)
        {
            PlayerEvent? playerEvent = db.PlayerEvents.Include(x => x.Room).Include(x => x.SubRoom).Include(x => x.Creator).FindById(request.PlayerEventId);
            if (playerEvent == null)
            {
                return NotFound();
            }
            RoomInstance? instance = db.RoomInstances.Include(x => x.SubRoom).FindById(request.BroadcastRoomInstanceId);
            if (instance == null)
            {
                return NotFound();
            }
            playerEvent.BroadcastingRoomInstanceId = request.BroadcastRoomInstanceId;
            db.PlayerEvents.Update(playerEvent);
            /*instance.InstanceType = RoomInstanceType.MultiInstanceEvent;
            instance.Private = true;
            db.RoomInstances.Update(instance);
            await ws.SendToAllPlayer("RoomInstanceUpdate", instance.ToDictionary());*/

            return Ok(new { Result = DNPDKMHJGAO.Success, PlayerEvent = playerEvent.ToDictionary() });
        }

        private AccountPresence GetOrCreatePresence(Account account)
        {
            var presence = db.Presences
                .Include(x => x.Account)
                .Include(x => x.Instance)
                .Include(x => x.Instance!.SubRoom)
                .Include(x => x.Instance!.SubRoom!.Room)
                .Include(x => x.Instance!.SubRoom!.Room!.Creator)
                .FindOne(x => x.Account.Id == account.Id);

            return presence ?? new AccountPresence { Account = account };
        }

        private async Task SaveAndNotifyPresenceAsync(AccountPresence presence)
        {
            presence.LastOnline = DateTime.UtcNow;
            presence.IsOnline = true;
            db.Presences.Upsert(presence);
            await ws.SendToAllPlayer("PresenceUpdate", presence.ToDictionary());
        }
    }
}