using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Security.Cryptography;
using Campus_live_rewrite.api.dbs;
using Campus_live_rewrite.api.server;
using Campus_live_rewrite.api.server.Classes;
using Campus_live_rewrite.api.server.Classes.db_class;

namespace Campus_live_rewrite.Controllers
{
    /// <summary>
    /// Settings > Export, the parts that need the server's data: "Export Data" (the player's own account as one JSON file) and
    /// "Export Rooms" (the rooms they CREATED, in the same folder layout the admin Archive import reads). Like Export Photos,
    /// the server only answers questions - the browser builds the zip, nothing is assembled or stored here. Auth is the WEBSITE
    /// session (campus_site cookie), and every room route re-checks that the signed-in player is the room's creator.
    ///
    /// What is deliberately NOT exported: the password hash, login tokens, device ids and IP addresses, 2FA secrets, messages
    /// with other players, and moderation records - they are either security material or other people's data.
    /// </summary>
    public class SiteExportController : ControllerBase
    {
        private const string SiteCookie = "campus_site";

        private player_info? CurrentUser()
        {
            string token = Request.Cookies[SiteCookie] ?? "";
            if (string.IsNullOrEmpty(token)) return null;
            string data = ClientSecurity.DecodeToken(token, requireSurface: "website");
            if (string.IsNullOrEmpty(data) || data.StartsWith("error_")) return null;
            try { return JsonConvert.DeserializeObject<player_info>(data); } catch { return null; }
        }

        private static string BlobDir => Path.Combine(Environment.CurrentDirectory, "Data", "CDN", "RoomBlobs");
        private static string ImageDir => Path.Combine(Environment.CurrentDirectory, "Data", "Images");

        // ---------------------------------------------------------------------------------------------
        // Export Data
        // ---------------------------------------------------------------------------------------------

        // GET /api/site/me/export - the player's own account as JSON. The browser saves it as a file.
        [HttpGet("/api/site/me/export")]
        public IActionResult ExportData()
        {
            var me = CurrentUser();
            if (me == null) return Unauthorized(new { ok = false, error = "not signed in" });
            var full = PlayerDB.GetFullAccount(me.Id);
            if (full?.player == null) return NotFound(new { ok = false, error = "account not found" });
            var p = full.player;
            var x = full.player_Extra ?? new player_extra();

            string Name(ulong id) => PlayerDB.GetAccountById(id)?.Username ?? "";

            var sitePrefs = SitePrefsDB.Get(me.Id);

            var friends = new List<object>();
            try
            {
                foreach (var r in FriendsDB.GetRelationships(me.Id))
                {
                    ulong other = r.PlayerID == me.Id ? r.OtherPlayerID : r.PlayerID;
                    friends.Add(new
                    {
                        accountId = other,
                        username = Name(other),
                        displayName = PlayerDB.GetAccountById(other)?.DisplayName ?? "",
                        relationship = r.RelationshipType.ToString(),
                        favorited = r.Favorited.ToString(),
                        muted = r.Muted.ToString(),
                        ignored = r.Ignored.ToString(),
                        voiceVolume = r.VoiceVolume,
                        nickname = SitePrefsDB.NicknameFor(me.Id, other),
                    });
                }
            }
            catch (Exception ex) { Console.WriteLine($"[export] {me.Id} friends failed: {ex.Message}"); }

            // Settings can hold anything the game stores; leave out anything that looks like a credential.
            var settings = new Dictionary<string, string?>();
            try
            {
                foreach (var s in SettingsDB.LoadSettings(me.Id))
                {
                    if (string.IsNullOrEmpty(s.Key)) continue;
                    string k = s.Key.ToLowerInvariant();
                    if (k.Contains("token") || k.Contains("password") || k.Contains("secret")) continue;
                    settings[s.Key] = s.Value;
                }
            }
            catch (Exception ex) { Console.WriteLine($"[export] {me.Id} settings failed: {ex.Message}"); }

            var rooms = RoomDB.col.Find(r => r.CreatorAccountId == me.Id).Select(r => new
            {
                roomId = r.RoomId, name = r.Name, description = r.Description, isDorm = r.IsDorm,
                createdAt = r.CreatedAt, accessibility = r.Accessibility.ToString(),
            }).ToList();

            var photos = new List<object>();
            try
            {
                foreach (var i in ImageMetadataDB.GetPlayerFeed(me.Id, me.Id, 0, 5000) ?? new())
                    photos.Add(new
                    {
                        id = i.SavedImageId, file = i.ImageName, description = i.Description, createdAt = i.CreatedAt,
                        takenByMe = i.PlayerId == me.Id,
                        taggedMe = i.TaggedPlayerIds != null && i.TaggedPlayerIds.Contains(me.Id),
                    });
            }
            catch (Exception ex) { Console.WriteLine($"[export] {me.Id} photos failed: {ex.Message}"); }

            var inventions = new List<object>();
            try
            {
                foreach (var v in InventionDB.GetByCreator(me.Id))
                    inventions.Add(new { id = v.InventionId, name = v.Name, description = v.Description, published = v.IsPublished, createdAt = v.CreatedAt, modifiedAt = v.ModifiedAt, tags = v.Tags });
            }
            catch (Exception ex) { Console.WriteLine($"[export] {me.Id} inventions failed: {ex.Message}"); }

            object? wishlist = null;
            try { wishlist = WishlistDB.For(me.Id).Select(w => new { storefront = w.StorefrontType, itemId = w.PurchasableItemId, customItem = w.CustomAvatarItemId, addedAt = w.CreatedAt }).ToList(); } catch { }

            var streak = LoginStreaks.Get(me.Id);

            var doc = new Dictionary<string, object?>
            {
                ["format"] = "campus-account-export",
                ["version"] = 1,
                ["exportedAt"] = DateTime.UtcNow,
                ["notIncluded"] = "Password, login tokens, device and IP records, two-factor secrets, messages with other players and moderation records are never exported.",
                ["account"] = new
                {
                    accountId = p.Id, username = p.Username, displayName = p.DisplayName, displayEmoji = p.DisplayEmoji,
                    email = p.Email, birthday = p.Birthday, bio = x.Bio,
                    level = p.Level, xp = p.XP, isJunior = p.IsJunior, avoidJuniors = p.AvoidJuniors,
                    pronounFlags = p.pronounFlags, identityFlags = p.identityFlags,
                    createdAt = p.created_at, lastLogin = p.last_login_time,
                    profileImage = p.profileImage, bannerImage = p.bannerImage,
                    platforms = (p.PlatformIds ?? new()).Select(i => i.Platform.ToString()).Distinct().ToList(),
                    photoTagging = x.PlayerPhotoTaggingSetting.ToString(),
                },
                ["balances"] = x.Balances.ToDictionary(b => Enum.IsDefined(typeof(CurrencyType), b.Key) ? ((CurrencyType)b.Key).ToString() : b.Key.ToString(), b => b.Value),
                ["avatar"] = new
                {
                    current = x.avatar,
                    savedOutfits = x.SavedOutfits,
                    ownedItems = x.AvatarItems,
                    customItems = x.CustomItems,
                    equipmentSkins = x.EquipmentSkins,
                    consumables = x.Consumables,
                },
                ["social"] = new
                {
                    friends,
                    followingAccountIds = x.SubbedTo,
                    followerCount = x.sub_count,
                    favoritedRoomIds = x.FavoritedRooms,
                    cheeredRoomIds = x.CheeredRooms,
                    recentRoomIds = p.recent_rooms,
                },
                ["progress"] = new
                {
                    dailyRewardClaims = x.DailyRewardClaims,
                    objectives = x.Objectives,
                    objectiveGroups = x.ObjectiveGroups,
                    challengeStatuses = x.ChallengeStatuses,
                    loginStreak = streak == null ? null : new { current = streak.Current, best = streak.Best, totalDays = streak.TotalDays, lastDay = streak.LastDay },
                },
                ["settings"] = settings,
                ["website"] = new { pinnedFriendIds = sitePrefs.Pinned, quickChat = sitePrefs.QuickChat },
                ["wishlist"] = wishlist,
                ["rooms"] = rooms,
                ["photos"] = photos,
                ["inventions"] = inventions,
            };

            Response.Headers["Cache-Control"] = "private, no-store";
            Console.WriteLine($"[export] {me.Id} exported their account data");
            return new ContentResult
            {
                Content = JsonConvert.SerializeObject(doc, Formatting.Indented, new Newtonsoft.Json.Converters.StringEnumConverter()),
                ContentType = "application/json"
            };
        }

        // ---------------------------------------------------------------------------------------------
        // Export Rooms (creator only)
        // ---------------------------------------------------------------------------------------------

        private static List<RoomDBClasses.RoomRoot> OwnedRooms(ulong me)
            => RoomDB.GetRoomsByCreator(me).OrderBy(r => r.Name, StringComparer.OrdinalIgnoreCase).ToList();

        // GET /api/site/me/rooms - the rooms this player created (only those), to pick from.
        [HttpGet("/api/site/me/rooms")]
        public IActionResult MyRooms()
        {
            var me = CurrentUser();
            if (me == null) return Unauthorized(new { ok = false, error = "not signed in" });
            var rooms = OwnedRooms(me.Id).Select(r => new
            {
                id = r.RoomId.ToString(),
                name = r.Name,
                isDorm = r.IsDorm,
                subrooms = (r.SubRooms ?? new()).Count,
            }).ToList();
            return Ok(new { ok = true, rooms });
        }

        // Every server file a room's export may include, by the name it has on disk.
        private sealed class ExportFile { public string Path = ""; public string Name = ""; public string Kind = ""; }

        private static string SafeName(string? s, string fallback)
        {
            var chars = (s ?? "").Where(c => char.IsLetterOrDigit(c) || c == '-' || c == '_' || c == ' ' || c == '.').ToArray();
            string t = new string(chars).Trim().Trim('.');
            if (t.Length > 40) t = t[..40].Trim();
            return t.Length == 0 ? fallback : t.Replace(' ', '_');
        }

        private static string? HashOf(string path)
        {
            try { using var fs = System.IO.File.OpenRead(path); return Convert.ToBase64String(SHA256.HashData(fs)); }
            catch { return null; }
        }

        // GET /api/site/me/rooms/{roomId}/manifest - RoomDetails.json plus the list of files to fetch. Layout matches the
        // admin Archive importer: <Room>/RoomDetails.json, RoomImage.<ext>, super_room_data.binpb,
        // SubRoom_<id>_<name>/persisted_room_data.binpb, plus every older save under that subroom's older_saves/.
        [HttpGet("/api/site/me/rooms/{roomId}/manifest")]
        public IActionResult RoomManifest(ulong roomId)
        {
            var me = CurrentUser();
            if (me == null) return Unauthorized(new { ok = false, error = "not signed in" });
            var room = OwnedRooms(me.Id).FirstOrDefault(r => r.RoomId == roomId);
            if (room == null) return NotFound(new { ok = false, error = "that room is not yours" });

            var files = new List<object>();
            var details = JObject.FromObject(room, JsonSerializer.CreateDefault(new JsonSerializerSettings { Converters = { new Newtonsoft.Json.Converters.StringEnumConverter() } }));

            void Add(string zipPath, string kind, string? name, string? hashInto, JObject? hashTarget)
            {
                if (string.IsNullOrWhiteSpace(name)) return;
                string disk = Path.Combine(kind == "image" ? ImageDir : BlobDir, Path.GetFileName(name));
                if (!System.IO.File.Exists(disk)) return;
                files.Add(new { path = zipPath, name = Path.GetFileName(name) });
                if (hashTarget != null && hashInto != null) { var h = HashOf(disk); if (h != null) hashTarget[hashInto] = h; }
            }

            // room-level data blob and picture
            Add("super_room_data.binpb", "blob", room.DataBlob, "DataBlobHash", details);
            if (!string.IsNullOrWhiteSpace(room.ImageName) && !room.ImageName.StartsWith("Default", StringComparison.OrdinalIgnoreCase))
                Add("RoomImage" + (Path.GetExtension(room.ImageName) is { Length: > 0 } ext ? ext : ".jpg"), "image", room.ImageName, null, null);

            var subs = details["SubRooms"] as JArray;
            foreach (var sub in room.SubRooms ?? new())
            {
                string folder = $"SubRoom_{sub.SubRoomId}_{SafeName(sub.Name, "subroom")}";
                var subTok = subs?.FirstOrDefault(t => (ulong?)t["SubRoomId"] == sub.SubRoomId) as JObject;
                if (sub.CurrentSave != null)
                    Add($"{folder}/persisted_room_data.binpb", "blob", sub.CurrentSave.DataBlob, "DataBlobHash", subTok?["CurrentSave"] as JObject);
                var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
                if (sub.CurrentSave?.DataBlob != null) seen.Add(sub.CurrentSave.DataBlob);
                int n = 0;
                foreach (var old in (sub.AllSaves ?? new()).OrderByDescending(s => s.CreatedAt))
                {
                    if (string.IsNullOrWhiteSpace(old.DataBlob) || !seen.Add(old.DataBlob)) continue;
                    n++;
                    Add($"{folder}/older_saves/{old.CreatedAt:yyyy-MM-dd_HH-mm}_{n}.binpb", "blob", old.DataBlob, null, null);
                }
            }

            Response.Headers["Cache-Control"] = "private, no-store";
            return Ok(new
            {
                ok = true,
                folder = $"{SafeName(room.Name, "room")}_{room.RoomId}",
                details = details.ToString(Formatting.Indented),
                files,
            });
        }

        // GET /api/site/me/rooms/{roomId}/file?name=<server file name> - one file of an owned room, by the name the manifest
        // listed. Only names the room itself references are served, so this can't read anything else from the server.
        [HttpGet("/api/site/me/rooms/{roomId}/file")]
        public IActionResult RoomFile(ulong roomId, [FromQuery] string? name)
        {
            var me = CurrentUser();
            if (me == null) return Unauthorized(new { ok = false, error = "not signed in" });
            var room = OwnedRooms(me.Id).FirstOrDefault(r => r.RoomId == roomId);
            if (room == null || string.IsNullOrWhiteSpace(name)) return NotFound();
            name = Path.GetFileName(name);

            bool isImage = string.Equals(name, room.ImageName, StringComparison.OrdinalIgnoreCase);
            bool isBlob = string.Equals(name, room.DataBlob, StringComparison.OrdinalIgnoreCase)
                || (room.SubRooms ?? new()).Any(s =>
                    string.Equals(s.CurrentSave?.DataBlob, name, StringComparison.OrdinalIgnoreCase)
                    || (s.AllSaves ?? new()).Any(a => string.Equals(a.DataBlob, name, StringComparison.OrdinalIgnoreCase)));
            if (!isImage && !isBlob) return NotFound();

            string disk = Path.Combine(isImage ? ImageDir : BlobDir, name);
            if (!System.IO.File.Exists(disk)) return NotFound();
            Response.Headers["Cache-Control"] = "private, no-store";
            return PhysicalFile(disk, "application/octet-stream");
        }
    }
}