using LiteDB;
using SixLabors.ImageSharp;
using SixLabors.ImageSharp.Formats.Jpeg;
using SixLabors.ImageSharp.Formats.Png;
using SixLabors.ImageSharp.PixelFormats;
using SixLabors.ImageSharp.Processing;

namespace Campus_live_rewrite.api.dbs
{
    /// <summary>
    /// Website support tickets. A signed-in player opens a ticket (the Support page's "talk to a
    /// real person" form); staff (dev / mod / owner / support flag) see EVERY ticket and can reply,
    /// add internal notes, claim, close and reopen. Stored in its own LiteDB file; checkpointed by
    /// DbMaintenance. Screenshots live in Data/SupportUploads (see the Attachment collection).
    ///
    /// Older tickets (before Category / read markers / claiming existed) load with those fields at
    /// their defaults and work unchanged - the category is read back out of the opening message.
    /// </summary>
    public static class SupportDB
    {
        private static readonly LiteDatabase DB =
            new LiteDatabase(Environment.CurrentDirectory + "/Data/DBs/Support.db");

        public static void Checkpoint() => DB.Checkpoint();

        private static ILiteCollection<Ticket> Tickets => DB.GetCollection<Ticket>("tickets");
        private static ILiteCollection<Attachment> Attachments => DB.GetCollection<Attachment>("attachments");
        private static readonly object Sync = new();

        public static readonly string UploadDir = Path.Combine(Environment.CurrentDirectory, "Data", "SupportUploads");

        // Limits (anti-spam) and housekeeping.
        public const int MaxOpenTicketsPerPlayer = 3;
        public static readonly TimeSpan NewTicketCooldown = TimeSpan.FromMinutes(1);
        public static readonly TimeSpan AutoCloseAfter = TimeSpan.FromDays(7);   // waiting on the player this long
        public const int MaxAttachmentsPerMessage = 4;
        public const int MaxAttachmentBytes = 6 * 1024 * 1024;

        // Screenshot anti-spam. The upload endpoint writes files to disk, so every one of these
        // is a hard server-side check - the page's own limits are only a convenience.
        public const int MaxPendingUploads = 8;                        // uploaded but not yet sent with a message
        public const int MaxUploadsPerDay = 30;                        // per player, rolling 24 h (persisted, survives restarts)
        public const long MaxUploadBytesPerDay = 40L * 1024 * 1024;    // per player, rolling 24 h, after re-encoding
        public const int MaxPlayerAttachmentsPerTicket = 20;           // the player's screenshots on one ticket (staff exempt)
        public const long UploadDirCapBytes = 2L * 1024 * 1024 * 1024; // whole folder; uploads stop (and it logs) past this
        public static readonly TimeSpan UnusedUploadLifetime = TimeSpan.FromHours(2);
        private const int MaxImageSide = 2560;                         // stored images are downscaled to fit this
        private const long MaxDecodePixels = 40_000_000;               // refuse "decompression bombs" before decoding

        static SupportDB()
        {
            Tickets.EnsureIndex(x => x.AccountId);
            Tickets.EnsureIndex(x => x.Status);
            Attachments.EnsureIndex(x => x.UploaderId);
            Directory.CreateDirectory(UploadDir);
        }

        public sealed class TicketMessage
        {
            public ulong FromAccountId { get; set; }
            public string FromName { get; set; } = "";
            public bool Staff { get; set; }
            public string Body { get; set; } = "";
            public DateTime At { get; set; } = DateTime.UtcNow;
            public bool Internal { get; set; }          // staff-only note, never shown to the player
            public bool System { get; set; }            // "Closed by @x", "Claimed by @y" ...
            public List<string>? Attachments { get; set; }
        }

        public sealed class Ticket
        {
            public int Id { get; set; }                 // LiteDB auto-increment PK
            public ulong AccountId { get; set; }
            public string Username { get; set; } = "";
            public string Subject { get; set; } = "";
            public string Status { get; set; } = "open"; // "open" | "closed"
            public string? Category { get; set; }        // account / join / econ / report_player / report_room / bug / appeal / other
            public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
            public DateTime UpdatedAt { get; set; } = DateTime.UtcNow;
            public List<TicketMessage> Messages { get; set; } = new();
            public DateTime? PlayerReadAt { get; set; }  // last time the player opened it
            public DateTime? StaffReadAt { get; set; }   // last time any staff member opened it
            public ulong AssignedTo { get; set; }        // claiming staff member (0 = unclaimed)
            public string? AssignedName { get; set; }
            public DateTime? ClosedAt { get; set; }
        }

        public sealed class Attachment
        {
            [BsonId] public string Name { get; set; } = "";   // random file name, e.g. "3f9c...png"
            public ulong UploaderId { get; set; }
            public int TicketId { get; set; }                  // 0 until a message claims it
            public string ContentType { get; set; } = "image/png";
            public long Bytes { get; set; }
            public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
        }

        // ---- derived state ------------------------------------------------------------------

        private static IEnumerable<TicketMessage> Public(Ticket t) => (t.Messages ?? new()).Where(m => !m.Internal);

        /// <summary>Whose turn it is on an open ticket: "staff" (the player spoke last) or "player".</summary>
        public static string AwaitingOf(Ticket t)
        {
            if (t.Status != "open") return "none";
            var last = Public(t).LastOrDefault(m => !m.System);
            return last == null || !last.Staff ? "staff" : "player";
        }

        /// <summary>Staff said something the player hasn't opened the ticket to see yet.</summary>
        public static bool UnreadForPlayer(Ticket t) =>
            Public(t).Any(m => m.Staff && m.FromAccountId != t.AccountId && m.At > (t.PlayerReadAt ?? DateTime.MinValue));

        /// <summary>The player said something no staff member has opened the ticket to see yet.</summary>
        public static bool UnreadForStaff(Ticket t) =>
            (t.Messages ?? new()).Any(m => !m.Staff && !m.System && m.At > (t.StaffReadAt ?? DateTime.MinValue));

        // ---- tickets ------------------------------------------------------------------------

        public static Ticket Create(ulong accountId, string username, string subject, string body, string? category, List<string>? attachments)
        {
            var t = new Ticket
            {
                AccountId = accountId,
                Username = username,
                Subject = string.IsNullOrWhiteSpace(subject) ? "Support request" : subject,
                Status = "open",
                Category = category,
                PlayerReadAt = DateTime.UtcNow,
            };
            t.Messages.Add(new TicketMessage { FromAccountId = accountId, FromName = username, Staff = false, Body = body, Attachments = attachments });
            lock (Sync)
            {
                Tickets.Insert(t);   // Id auto-assigned
                ClaimAttachments(attachments, t.Id);
            }
            return t;
        }

        public static Ticket? Get(int id) => Tickets.FindById(id);

        public static List<Ticket> ForAccount(ulong accountId)
        {
            AutoCloseStale();
            return Tickets.Find(x => x.AccountId == accountId).OrderByDescending(x => x.UpdatedAt).ToList();
        }

        public static List<Ticket> All(string? status)
        {
            AutoCloseStale();
            var rows = status == "open"   ? Tickets.Find(x => x.Status == "open")
                     : status == "closed" ? Tickets.Find(x => x.Status == "closed")
                     : Tickets.FindAll();
            return rows.OrderByDescending(x => x.UpdatedAt).ToList();
        }

        /// <summary>Add a reply (or, for staff, an internal note). A public reply reopens a closed ticket.</summary>
        public static Ticket? AddMessage(int id, ulong fromId, string fromName, bool staff, string body, bool isInternal, List<string>? attachments)
        {
            lock (Sync)
            {
                var t = Tickets.FindById(id);
                if (t == null) return null;
                var now = DateTime.UtcNow;
                t.Messages.Add(new TicketMessage { FromAccountId = fromId, FromName = fromName, Staff = staff, Body = body, At = now, Internal = isInternal && staff, Attachments = attachments });
                if (!(isInternal && staff))
                {
                    t.UpdatedAt = now;
                    // A reply on a closed ticket reopens it, so nobody's follow-up is lost in a closed thread.
                    if (t.Status == "closed")
                    {
                        t.Status = "open"; t.ClosedAt = null;
                        t.Messages.Add(new TicketMessage { FromAccountId = fromId, FromName = fromName, Staff = staff, System = true, Body = $"Reopened by the reply from @{fromName}", At = now.AddMilliseconds(1) });
                    }
                }
                // Writing in a ticket means you've read it.
                if (staff && fromId != t.AccountId) t.StaffReadAt = now; else t.PlayerReadAt = now;
                Tickets.Update(t);
                ClaimAttachments(attachments, id);
                return t;
            }
        }

        public static Ticket? SetStatus(int id, string status, ulong byId, string byName, bool byStaff)
        {
            lock (Sync)
            {
                var t = Tickets.FindById(id);
                if (t == null || t.Status == status) return t;
                var now = DateTime.UtcNow;
                t.Status = status;
                t.UpdatedAt = now;
                t.ClosedAt = status == "closed" ? now : null;
                string who = byId == t.AccountId ? "the player" : "@" + byName;
                t.Messages.Add(new TicketMessage { FromAccountId = byId, FromName = byName, Staff = byStaff, System = true, At = now,
                    Body = status == "closed" ? $"Ticket closed by {who}" : $"Ticket reopened by {who}" });
                if (byStaff && byId != t.AccountId) t.StaffReadAt = now; else t.PlayerReadAt = now;
                Tickets.Update(t);
                return t;
            }
        }

        /// <summary>Claim (staffId != 0) or release (0) a ticket. Recorded in the thread for staff only.</summary>
        public static Ticket? Assign(int id, ulong staffId, string staffName, ulong byId, string byName)
        {
            lock (Sync)
            {
                var t = Tickets.FindById(id);
                if (t == null) return null;
                t.AssignedTo = staffId;
                t.AssignedName = staffId == 0 ? null : staffName;
                t.Messages.Add(new TicketMessage { FromAccountId = byId, FromName = byName, Staff = true, System = true, Internal = true, At = DateTime.UtcNow,
                    Body = staffId == 0 ? $"Released by @{byName}" : (staffId == byId ? $"Claimed by @{byName}" : $"Assigned to @{staffName} by @{byName}") });
                t.StaffReadAt = DateTime.UtcNow;
                Tickets.Update(t);
                return t;
            }
        }

        public static void MarkRead(int id, bool asStaff)
        {
            lock (Sync)
            {
                var t = Tickets.FindById(id);
                if (t == null) return;
                if (asStaff) t.StaffReadAt = DateTime.UtcNow; else t.PlayerReadAt = DateTime.UtcNow;
                Tickets.Update(t);
            }
        }

        public static int OpenCount() => Tickets.Count(x => x.Status == "open");
        public static int AwaitingStaffCount() => Tickets.Find(x => x.Status == "open").Count(t => AwaitingOf(t) == "staff");
        public static int OpenCountFor(ulong accountId) => Tickets.Count(x => x.AccountId == accountId && x.Status == "open");
        public static DateTime? LastCreatedBy(ulong accountId) =>
            Tickets.Find(x => x.AccountId == accountId).Select(x => (DateTime?)x.CreatedAt).DefaultIfEmpty(null).Max();

        // Tickets waiting on the PLAYER for AutoCloseAfter are closed with a note (they can reopen by
        // replying). Run lazily from the list reads, at most every 10 minutes.
        private static DateTime _lastSweep = DateTime.MinValue;
        private static void AutoCloseStale()
        {
            if ((DateTime.UtcNow - _lastSweep).TotalMinutes < 10) return;
            _lastSweep = DateTime.UtcNow;
            try
            {
                var cutoff = DateTime.UtcNow - AutoCloseAfter;
                foreach (var t in Tickets.Find(x => x.Status == "open").ToList())
                {
                    if (AwaitingOf(t) != "player") continue;
                    var last = Public(t).LastOrDefault(m => !m.System);
                    if (last == null || last.At > cutoff) continue;
                    lock (Sync)
                    {
                        t.Status = "closed"; t.ClosedAt = DateTime.UtcNow; t.UpdatedAt = DateTime.UtcNow;
                        t.Messages.Add(new TicketMessage { System = true, Staff = true, FromName = "Campus", At = DateTime.UtcNow,
                            Body = $"Closed automatically after {AutoCloseAfter.TotalDays:0} days without a reply. Reply to reopen it." });
                        Tickets.Update(t);
                    }
                    Console.WriteLine($"[support] ticket #{t.Id} auto-closed (no reply from @{t.Username} in {AutoCloseAfter.TotalDays:0} days)");
                }
            }
            catch (Exception ex) { Console.WriteLine($"[support] auto-close sweep failed: {ex.Message}"); }
        }

        // ---- screenshots --------------------------------------------------------------------

        /// <summary>
        /// Why this player may not upload another screenshot right now, or null when they may.
        /// Checked BEFORE the image is read or decoded, so a refused caller costs nothing.
        /// </summary>
        public static string? UploadRefusal(ulong uploaderId)
        {
            SweepUnusedUploads();
            var since = DateTime.UtcNow.AddDays(-1);
            List<Attachment> mine;
            lock (Sync) mine = Attachments.Find(x => x.UploaderId == uploaderId).ToList();
            if (mine.Count(a => a.TicketId == 0) >= MaxPendingUploads)
                return $"You have {MaxPendingUploads} screenshots waiting to be sent. Send your message (or remove some) before adding more.";
            var today = mine.Where(a => a.CreatedAt > since).ToList();
            if (today.Count >= MaxUploadsPerDay || today.Sum(a => a.Bytes) >= MaxUploadBytesPerDay)
                return "You've attached a lot of screenshots today. Please try again tomorrow, or describe the problem in words.";
            if (UploadDirBytes() >= UploadDirCapBytes)
            {
                Console.WriteLine($"[support] screenshot upload refused: {UploadDir} is over its {UploadDirCapBytes / 1024 / 1024} MB cap");
                return "Screenshots are unavailable right now. Please describe the problem in words.";
            }
            return null;
        }

        /// <summary>
        /// Store an uploaded screenshot. The bytes are never written as uploaded: the image is
        /// decoded and re-encoded (PNG stays PNG, everything else becomes JPEG), which means a
        /// renamed file, a polyglot or a malformed image never lands on disk, EXIF (phone GPS
        /// location) is stripped, and huge images are downscaled. Returns the stored name, or
        /// null when it isn't a readable PNG/JPEG/GIF/WebP.
        /// </summary>
        public static string? SaveAttachment(ulong uploaderId, byte[] data)
        {
            string? ext = SniffImage(data, out _);
            if (ext == null || data.Length == 0 || data.Length > MaxAttachmentBytes) return null;
            byte[] stored;
            string contentType;
            try
            {
                var info = Image.Identify(data);                   // header only - no pixel decode
                if (info == null || info.Width < 1 || info.Height < 1 || (long)info.Width * info.Height > MaxDecodePixels) return null;
                using var img = Image.Load<Rgba32>(data);
                if (img.Width > MaxImageSide || img.Height > MaxImageSide)
                    img.Mutate(x => x.Resize(new ResizeOptions { Mode = ResizeMode.Max, Size = new Size(MaxImageSide, MaxImageSide) }));
                img.Metadata.ExifProfile = null;
                img.Metadata.XmpProfile = null;
                img.Metadata.IccProfile = null;
                using var outMs = new MemoryStream();
                // SkipMetadata: no text/EXIF/XMP chunks survive - only pixels are written back.
                if (ext == ".png") { img.SaveAsPng(outMs, new PngEncoder { SkipMetadata = true }); contentType = "image/png"; }
                else { img.SaveAsJpeg(outMs, new JpegEncoder { Quality = 88, SkipMetadata = true }); contentType = "image/jpeg"; ext = ".jpg"; }
                stored = outMs.ToArray();
            }
            catch { return null; }                                  // not actually an image

            string name = Convert.ToHexString(System.Security.Cryptography.RandomNumberGenerator.GetBytes(16)).ToLowerInvariant() + ext;
            File.WriteAllBytes(Path.Combine(UploadDir, name), stored);
            lock (Sync) Attachments.Insert(new Attachment { Name = name, UploaderId = uploaderId, ContentType = contentType, Bytes = stored.Length });
            UploadDirBytes();
            Interlocked.Add(ref _dirBytes, stored.Length);
            return name;
        }

        /// <summary>The uploader removed a screenshot before sending it: delete it now.</summary>
        public static bool DeleteUnsent(ulong uploaderId, string name)
        {
            Attachment? a;
            lock (Sync)
            {
                a = Attachments.FindById(name);
                if (a == null || a.UploaderId != uploaderId || a.TicketId != 0) return false;
                Attachments.Delete(name);
            }
            try { File.Delete(Path.Combine(UploadDir, a.Name)); } catch { }
            UploadDirBytes();
            Interlocked.Add(ref _dirBytes, -a.Bytes);
            return true;
        }

        /// <summary>How many screenshots this player has already put on the ticket.</summary>
        public static int PlayerAttachmentCount(Ticket t, ulong playerId) =>
            (t.Messages ?? new()).Where(m => m.FromAccountId == playerId && !m.Staff).Sum(m => m.Attachments?.Count ?? 0);

        // Total size of the upload folder: counted from disk once, then kept up to date.
        private static long _dirBytes = -1;
        private static long UploadDirBytes()
        {
            if (Interlocked.Read(ref _dirBytes) < 0)
            {
                long total = 0;
                try { foreach (var f in new DirectoryInfo(UploadDir).EnumerateFiles()) total += f.Length; } catch { }
                Interlocked.CompareExchange(ref _dirBytes, total, -1);
            }
            return Interlocked.Read(ref _dirBytes);
        }

        // Screenshots that were uploaded but never sent with a message (the player closed the
        // form, or a script uploaded and walked away) are deleted after UnusedUploadLifetime.
        private static DateTime _lastUploadSweep = DateTime.MinValue;
        private static void SweepUnusedUploads()
        {
            if ((DateTime.UtcNow - _lastUploadSweep).TotalMinutes < 10) return;
            _lastUploadSweep = DateTime.UtcNow;
            try
            {
                var cutoff = DateTime.UtcNow - UnusedUploadLifetime;
                List<Attachment> stale;
                lock (Sync) stale = Attachments.Find(x => x.TicketId == 0 && x.CreatedAt < cutoff).ToList();
                UploadDirBytes();
                foreach (var a in stale)
                {
                    try { File.Delete(Path.Combine(UploadDir, a.Name)); } catch { }
                    lock (Sync) Attachments.Delete(a.Name);
                    Interlocked.Add(ref _dirBytes, -a.Bytes);
                }
                if (stale.Count > 0) Console.WriteLine($"[support] deleted {stale.Count} unused screenshot upload(s)");
            }
            catch (Exception ex) { Console.WriteLine($"[support] upload sweep failed: {ex.Message}"); }
        }

        /// <summary>The uploader's own not-yet-used uploads among these names (anything else is dropped).</summary>
        public static List<string> OwnUnclaimed(ulong uploaderId, IEnumerable<string>? names)
        {
            var list = new List<string>();
            foreach (var n in (names ?? Enumerable.Empty<string>()).Distinct().Take(MaxAttachmentsPerMessage))
            {
                var a = Attachments.FindById(n);
                if (a != null && a.UploaderId == uploaderId && a.TicketId == 0) list.Add(n);
            }
            return list;
        }

        private static void ClaimAttachments(List<string>? names, int ticketId)
        {
            foreach (var n in names ?? new())
            {
                var a = Attachments.FindById(n);
                if (a == null) continue;
                a.TicketId = ticketId;
                Attachments.Update(a);
            }
        }

        public static Attachment? GetAttachment(string name) => Attachments.FindById(name);

        private static string? SniffImage(byte[] d, out string contentType)
        {
            contentType = "";
            if (d.Length > 8 && d[0] == 0x89 && d[1] == 0x50 && d[2] == 0x4E && d[3] == 0x47) { contentType = "image/png"; return ".png"; }
            if (d.Length > 3 && d[0] == 0xFF && d[1] == 0xD8 && d[2] == 0xFF) { contentType = "image/jpeg"; return ".jpg"; }
            if (d.Length > 6 && d[0] == 'G' && d[1] == 'I' && d[2] == 'F' && d[3] == '8') { contentType = "image/gif"; return ".gif"; }
            if (d.Length > 12 && d[0] == 'R' && d[1] == 'I' && d[2] == 'F' && d[3] == 'F' && d[8] == 'W' && d[9] == 'E' && d[10] == 'B' && d[11] == 'P') { contentType = "image/webp"; return ".webp"; }
            return null;
        }
    }
}