using DeluxeBackend.Extensions;
using DeluxeBackend.Models;
using DeluxeBackend.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json.Linq;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Numerics;
using System.Security.Principal;
using System.Text.Json;
using System.Text.Json.Serialization;
using static DeluxeBackend.Enums;
using static DeluxeBackend.Extensions.RoomExtensions;

namespace DeluxeBackend.Controllers
{
    [Route("Rooms")]
    [ApiController]
    public class RoomsController : ControllerBase
    {
        private readonly ILiteDbService db;
        private readonly IJwtService jwt;
        private readonly ICdnService cdn;
        private readonly DiscordBotService discord;
        private readonly bool setup = false;

        public RoomsController(ILiteDbService _db, IJwtService _jwtService, DiscordBotService _discord, ICdnService _cdn)
        {
            db = _db;
            jwt = _jwtService;
            discord = _discord;
            cdn = _cdn;

            if (!setup)
            {
                setup = true;
                var json = System.IO.File.ReadAllText(Path.Combine("data", "AGRoomRuntimeConfig.json"));
                AGRoomRuntimeConfig activityRuntimeConfig = JsonSerializer.Deserialize<AGRoomRuntimeConfig>(json) ?? throw new Exception("Failed to deserialize");
                Account mainPlayer = db.Accounts.FindById(1) ?? throw new Exception("player not found");

                foreach (AGRoomRuntimeConfig.Room room in activityRuntimeConfig.Rooms)
                {
                    if (db.Rooms.FindOne(x => x.Name == room.Name) != null)
                    {
                        continue;
                    }
                    Room newRoom = new Room
                    {
                        Accessibility = room.Accessibility,
                        Name = room.Name,
                        Description = room.Description,
                        CloningAllowed = room.CloningAllowed,
                        Creator = mainPlayer,
                        CustomWarning = room.CustomRoomWarning,
                        WarningMask = room.RoomWarningMask,
                        DisableMicAutoMute = room.DisableMicAutoMute,
                        DisableRoomComments = room.DisableRoomComments,
                        EncryptVoiceChat = false,
                        IsDorm = room.Name == "DormRoom",
                        IsRRO = true,
                    };

                    RoomSupports RoomSup = RoomSupports.None;
                    if (room.SupportsScreens) RoomSup |= RoomSupports.Screens;
                    if (room.SupportsWalkVR) RoomSup |= RoomSupports.WalkVR;
                    if (room.SupportsTeleportVR) RoomSup |= RoomSupports.TeleportVR;

                    RoomSup |= RoomSupports.Juniors;
                    newRoom.SupportedPlayerTypes = RoomSup;

                    db.Rooms.Insert(newRoom);

                    foreach (var scene in room.Scenes)
                    {
                        SubRoom newScene = new()
                        {
                            Room = newRoom,
                            LocationId = scene.RoomSceneLocationId,
                            Name = scene.Name,
                            IsSandbox = scene.IsSandbox,
                            MaxPlayers = scene.MaxPlayers,
                            CanMatchmakeInto = scene.CanMatchmakeInto,
                            SupportsJoinInProgress = scene.SupportsJoinInProgress,
                            UseLevelBasedMatchmaking = scene.UseLevelBasedMatchmaking,
                            UseAgeBasedMatchmaking = scene.UseAgeBasedMatchmaking,
                            UseRecRoyaleMatchmaking = scene.UseRecRoyaleMatchmaking
                        };
                        db.SubRooms.Insert(newScene);
                    }
                }
            }
        }



        

        

        [HttpGet("rooms/hot")]
        public async Task<IActionResult> Hot([FromQuery] string? tag, [FromQuery] int skip = 0, [FromQuery] int take = 32)
        {
            var query = db.Rooms.Query().Where(x => x.Accessibility == RoomAccessibility.Public);

            if (!string.IsNullOrWhiteSpace(tag))
            {
                if (tag.ToLower() == "rro")
                {
                    query = query.Where(x => x.IsRRO == true);
                }
            }

            var roomEntities = query.OrderByDescending(x => x.Stats.VisitCount).Skip(skip).Limit(take).ToList();

            var tasks = roomEntities.Select(async p => await p.ToDictionary(discord, db));
            var rooms = (await Task.WhenAll(tasks)).ToList();

            return Ok(new
            {
                Results = rooms,
                TotalResults = rooms.Count
            });
        }

        [HttpGet("rooms/{roomId}/subrooms/{subroomId}/saves")]
        [Authorize]
        public async Task<IActionResult> RoomSaves([FromRoute] int roomId, [FromRoute] int subroomId, [FromQuery] int skip, [FromQuery] int take)
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return NotFound("User not found in database");

            Room? room = db.Rooms.Include(x => x.Creator).FindById(roomId);
            if (room == null) return NotFound();

            if (!room.HasRole(account.Id, RoomRoleType.CoOwner))
            {
                return StatusCode(403);
            }

            SubRoom? subRoom = db.SubRooms.Include(x => x.Room).FindById(subroomId);
            if (subRoom == null) return NotFound();
            if (subRoom.Room.Id != roomId)
            {
                return NotFound();
            }

            var saves = db.SubRoomSave.Find(x => x.SubRoomId == subroomId).OrderByDescending(x => x.Id);
            List<SubRoomSave> subRoomSaves = saves.Skip(skip).Take(take).ToList();

            return Ok(new
            {
                Results = subRoomSaves.Select(x => x.ToDictionary()).ToList(),
                TotalResults = saves.Count()
            });
        }

        [HttpPut("rooms/{roomId}/subrooms/{subroomId}/permissions")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> Permissions([FromRoute] int roomId, [FromRoute] int subroomId)
        {
            return Ok(new
            {
                Success = true
            });
        }

        /*[HttpGet("subroom/{subroomId}/MakeSAVE")]
        public async Task<IActionResult> MakeSave([FromRoute] int subroomId, [FromQuery] string DataBlob, [FromQuery] string? UnityAssetId = null)
        {
            SubRoom? room = db.SubRooms.FindById(subroomId);
            if (room == null) return NotFound();

            SubRoomSave Save = new SubRoomSave()
            {
                DataBlob = DataBlob,
                SubRoomId = subroomId,
                UnityAssetId = UnityAssetId
            };
            db.SubRoomSave.Insert(Save);
            room.CurrentSave = Save;
            db.SubRooms.Update(room);

            return Ok(new { hiii = "meow :3" });
        }*/

        [HttpGet("rooms/createdby/me")]
        [Authorize]
        public async Task<IActionResult> CreatedbyMe()
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return NotFound("User not found in database");

            List<Dictionary<string, object>> response = [];
            var foundRooms = db.Rooms.Include(x => x.Creator).Find(x => x.Creator != null && x.Creator.Id == account.Id);

            foreach (var room in foundRooms)
            {
                response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
            }

            return Ok(response);
        }

        [HttpGet("rooms/ownedby/me")]
        [Authorize]
        public async Task<IActionResult> OwnedbybyMe()
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return NotFound("User not found in database");

            List<Dictionary<string, object>> response = [];

            var foundRooms = db.Rooms.Include(x => x.Creator)
                .FindAll()
                .Where(x =>
                    (x.Creator != null && x.Creator.Id == account.Id) ||
                    (x.Roles != null && x.Roles.Any(r => r.AccountId == account.Id && r.Role >= RoomRoleType.CoOwner))
                );

            foreach (var room in foundRooms)
            {
                response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
            }

            return Ok(response);
        }

        [HttpGet("photon_access_token")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> PhotonAccessToken()
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return NotFound("User not found in database");

            AccountPresence 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);

            if (presence == null) return NotFound("");
            if (presence.Instance == null) return BadRequest("Not in a Instance");

            return Ok(new
            {
                RoomInstanceId = presence.Instance.Id,
                PhotonAccessToken = "Meow",
                Permissions = new List<object>()
            });
        }

        [HttpGet("unity_assets/{UnityAssetId}/{Target}/{Version}")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> UnityAssetss([FromRoute] Guid UnityAssetId, [FromRoute] AssetBundleType Target, AssetBundleVersion Version)
        {

            if (Target == AssetBundleType.OculusQuest)
            {
                Target = AssetBundleType.MobileAndroid;
            }
            UnityAssets unityAssets = db.UnityAssets.FindById(UnityAssetId);
            if (unityAssets == null) return NotFound();

            UnityAsset? unityAsset = unityAssets.Assets.FirstOrDefault(u => u.Target == Target && u.Version == Version);
            if (unityAsset == null) return NotFound();

            return Ok(new
            {
                UnityAssetId,
                Target,
                Version,
                unityAsset.Filename
            });
        }

        [HttpGet("rooms/ownedby/{accId}")]
        public async Task<IActionResult> RoomsOwnedby(long accId)
        {
            List<Dictionary<string, object>> response = [];

            var foundRooms = db.Rooms.Include(x => x.Creator)
                .FindAll()
                .Where(x =>
                    x.Accessibility == RoomAccessibility.Public &&
                    (
                        (x.Creator != null && x.Creator.Id == accId) ||
                        (x.Roles != null && x.Roles.Any(r => r.AccountId == accId && r.Role >= RoomRoleType.CoOwner))
                    )
                );

            foreach (var room in foundRooms)
            {
                response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
            }

            return Ok(response);
        }


        [HttpGet("rooms/base")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> Base()
        {
            List<Dictionary<string, object>> response = [];
            var foundRooms = db.Rooms.Include(x => x.Creator).Find(x => x.Accessibility == RoomAccessibility.Unlisted && x.CloningAllowed == true);

            foreach (var room in foundRooms)
            {
                response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
            }

            return Ok(response);
        }

        [HttpPost("rooms/{roomId}/clone")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> Clone(long roomId, [FromForm, Required] string name)
        {
            LoginWithInfoResult? login = await jwt.GetLoginWithInfo(User);
            if (login == null) return Unauthorized();

            Account account = login.Account;
            Room? room = db.Rooms.Include(x => x.Creator).FindById(roomId);
            if (room == null) return NotFound();

            if (string.IsNullOrWhiteSpace(name) || name.Length < 3 || name.Length > 32)
            {
                return BadRequest(new { Success = false, Error = "Room name must be between 3 and 32 characters." });
            }

            if (!room.CloningAllowed && !room.HasRole(account.Id, RoomRoleType.CoOwner))
            {
                return Forbid();
            }

            if (db.Rooms.FindOne(x => x.Name.Equals(name, StringComparison.OrdinalIgnoreCase)) != null)
            {
                return Conflict(new { Success = false, Error = $"The room name '{name}' is already taken." });
            }

            Room newRoom = new()
            {
                Name = name.Trim(),
                SupportedPlayerTypes = room.SupportedPlayerTypes,
                Accessibility = RoomAccessibility.Private,
                ImageName = room.ImageName,
                Description = room.Description,
                Creator = account,
                CustomWarning = room.CustomWarning,
                WarningMask = room.WarningMask,
                DataBlob = room.DataBlob,
                DisableMicAutoMute = room.DisableMicAutoMute,
                DisableRoomComments = room.DisableRoomComments,
                EncryptVoiceChat = room.EncryptVoiceChat,
                MinLevel = room.MinLevel,
                PersistenceVersion = room.PersistenceVersion
            };
            db.Rooms.Insert(newRoom);

            foreach (SubRoom subRoom in db.SubRooms.Include(x => x.Room).Include(x => x.CurrentSave).Find(x => x.Room.Id == roomId))
            {
                SubRoom newSubroom = new()
                {
                    Room = newRoom,
                    LocationId = subRoom.LocationId,
                    Name = subRoom.Name,
                    IsSandbox = subRoom.IsSandbox,
                    MaxPlayers = subRoom.MaxPlayers,
                    CanMatchmakeInto = subRoom.CanMatchmakeInto,
                    SupportsJoinInProgress = subRoom.SupportsJoinInProgress,
                    UseLevelBasedMatchmaking = subRoom.UseLevelBasedMatchmaking,
                    UseAgeBasedMatchmaking = subRoom.UseAgeBasedMatchmaking,
                    UseRecRoyaleMatchmaking = subRoom.UseRecRoyaleMatchmaking
                };
                db.SubRooms.Insert(newSubroom);

                if (subRoom.CurrentSave != null)
                {
                    SubRoomSave newSave = new()
                    {
                        SubRoomId = newSubroom.Id,
                        DataBlob = subRoom.CurrentSave.DataBlob,
                        SavedByAccountId = account.Id,
                        SavedOnPlatform = login.Platform,
                        SavedOnDeviceClass = login.DeviceClass,
                        Description = $"Cloned From ^{room.Name}",
                        UnityAssetId = subRoom.CurrentSave.UnityAssetId,
                        PersistenceVersion = subRoom.CurrentSave.PersistenceVersion
                    };
                    db.SubRoomSave.Insert(newSave);
                    newSubroom.CurrentSave = newSave;
                    db.SubRooms.Update(newSubroom);
                }
            }

            return Ok(new { Success = true, Value = await newRoom.ToDictionary(discord, db, RoomDetailsMask.StandardDetails) });
        }

        [HttpGet("rooms/moderatedby/me")]
        public async Task<IActionResult> ModerateByNe()
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return NotFound("User not found in database");

            List<Dictionary<string, object>> response = [];

            var foundRooms = db.Rooms.Include(x => x.Creator)
                .FindAll()
                .Where(x =>
                    (x.Creator != null && x.Creator.Id == account.Id) ||
                    (x.Roles != null && x.Roles.Any(r => r.AccountId == account.Id && r.Role >= RoomRoleType.Moderator))
                );

            foreach (var room in foundRooms)
            {
                response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
            }

            return Ok(response);
        }
        public class UploadDTO
        {
            [JsonPropertyName("Filename")]
            public required string filename { get; set; }
            [JsonPropertyName("Hash")]
            public required string hash { get; set; }
            [JsonPropertyName("OwnershipProof")]
            public required string ownershipProof { get; set; }

        }
        public class SaveSubroomDTO
        {
            [JsonPropertyName("AutoPublish")]
            public bool autoPublish { get; set; } = false;
            [JsonPropertyName("Description")]
            public string? description { get; set; } = null;
            [JsonPropertyName("RoomData")]
            public required UploadDTO roomData { get; set; }
            [JsonPropertyName("SubRoomData")]
            public required UploadDTO SubRoomData { get; set; }
            [JsonPropertyName("UnityAssetId")]
            public string? unityAssetId { get; set; } = null;
            [JsonPropertyName("PersistenceVersion")]
            public int persistenceVersion { get; set; }

        }

        [HttpPost("rooms/{roomId}/subrooms/{subroomId}/data")]
        [Authorize(Roles = "gameClient")]
        public async Task<IActionResult> SubRoonData(long roomId, long subroomId, [FromBody, Required] SaveSubroomDTO request)
        {
            LoginWithInfoResult? login = await jwt.GetLoginWithInfo(User);
            
            if (login == null) return Unauthorized();
            Account account = login.Account;
            Room? room = db.Rooms.Include(x => x.Creator).FindById(roomId);
            if (room == null) return NotFound();

            if (!room.HasRole(account.Id, RoomRoleType.CoOwner))
            {
                return StatusCode(403);
            }

            SubRoom? subRoom = db.SubRooms.Include(x => x.Room).FindById(subroomId);
            if (subRoom == null) return NotFound();
            if (subRoom.Room.Id != roomId)
            {
                return NotFound();
            }
            if (request.roomData.ownershipProof != CdnService.GenerateOwnershipProof(account, request.roomData.filename))
            {
                return Ok(new { Success = false, Error = "Room Ownership Proof Mismatch!" });
            }
            if (request.SubRoomData.ownershipProof != CdnService.GenerateOwnershipProof(account, request.SubRoomData.filename))
            {
                return Ok(new { Success = false, Error = "Subroom Ownership Proof Mismatch!" });
            }

            if (room.Accessibility == RoomAccessibility.Private)
            {
                request.autoPublish = true;
            }

            SubRoomSave save = new()
            {
                SubRoomId = subroomId,
                DataBlob = request.SubRoomData.filename,
                SavedByAccountId = account.Id,
                Description = request.description,
                UnityAssetId = request.unityAssetId,
                SavedOnPlatform=login.Platform,
                SavedOnDeviceClass=login.DeviceClass,
                PersistenceVersion = request.persistenceVersion,
            };
            db.SubRoomSave.Insert(save);
            if (request.autoPublish)
            {
                subRoom.CurrentSave = save;
                db.SubRooms.Update(subRoom);
            }
            room.DataBlob = request.roomData.filename;
            room.PersistenceVersion = request.persistenceVersion;
            db.Rooms.Update(room);

            return Ok(new { Success = true, Value = new Dictionary<string, object> { ["Room"] = await room.ToDictionary(discord, db, RoomDetailsMask.StandardDetails), ["SubRoomDataSave"] = save.ToDictionary()} });
        }

        [HttpGet("rooms/visitedby/{accId}")]
        [Authorize]
        public async Task<IActionResult> VisitedBy(long accId)
        {
            Account? account = db.Accounts.FindById(accId);
            if (account == null) return NotFound();
            if (!account.IsRecentHistoryVisible)
            {
                return StatusCode(403);
            }

            List<Dictionary<string, object>> response = [];

            var visitedRoomIds = account.VisitedRooms.Keys.ToList();

            if (visitedRoomIds.Count > 0)
            {
                var foundRooms = db.Rooms.Include(x => x.Creator)
                .FindAll()
                .Where(x => visitedRoomIds.Contains(x.Id))
                .ToList().Where(room => room.Accessibility == RoomAccessibility.Public).OrderByDescending(room => account.VisitedRooms.TryGetValue(room.Id, out var date) ? date : DateTime.MinValue);

                foreach (var room in foundRooms)
                {
                    response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
                }
            }

            return Ok(response);
        }

        [HttpGet("rooms/visitedby/me")]
        [Authorize]
        public async Task<IActionResult> VisitedByMe()
        {
            Account? account = await jwt.GetLogin(User);
            if (account == null) return Unauthorized();

            List<Dictionary<string, object>> response = [];

            var visitedRoomIds = account.VisitedRooms.Keys.ToList();

            if (visitedRoomIds.Count > 0)
            {
                var foundRooms = db.Rooms.Include(x => x.Creator)
                .FindAll()
                .Where(x => visitedRoomIds.Contains(x.Id))
                .ToList().Where(room => room.Accessibility == RoomAccessibility.Public || room.HasRole(account.Id, RoomRoleType.CoOwner)).OrderByDescending(room => account.VisitedRooms.TryGetValue(room.Id, out var date) ? date : DateTime.MinValue);                    

                foreach (var room in foundRooms)
                {
                    response.Add(await room.ToDictionary(discord, db, RoomDetailsMask.None));
                }
            }

            return Ok(response);
        }
    }
}