using CSharpDiscordWebhook.Objects;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using RadicadeServer.DB;
using RadicadeServer.Extensions;
using RadicadeServer.RecNet.Enums.Inventions;
using RadicadeServer.RecNet;
using RadicadeServer.RecNet.Inventions;
using RadicadeServer.RecNet.Responses;
using RadicadeServer.RecNet.Rooms;
using RadicadeServer.Utils;

namespace RadicadeServer.API.Inventions.V1
{
	[Route("api/inventions/v1")]
	public class InventionsV1(RecDBContext db) : Controller
	{
		[HttpGet("room")]
		public List<object> GetInventionsInRoom()
		{
			return [];
		}

		[HttpGet("fromcreators")]
		public async Task<IActionResult> GetInventionsFromCreators(
			[FromQuery] long[]? id,
			[FromQuery] int skip = 0,
			[FromQuery] int take = 100)
		{
			if (id == null || id.Length == 0)
				return BadRequest(new { error = "At least one creator id is required." });

			var creatorIds = id.Where(creatorId => creatorId > 0).Distinct().ToArray();
			var offset = Math.Max(0, skip);
			var limit = Math.Clamp(take, 1, 100);
			var inventions = await db.Inventions
				.Where(invention => creatorIds.Contains(invention.CreatorPlayerId))
				.OrderByDescending(invention => invention.CreatedAt)
				.ThenByDescending(invention => invention.InventionId)
				.Skip(offset)
				.Take(limit)
				.ToListAsync();

			return Ok(inventions.Select(invention => invention.ToInvention()).ToList());
		}

		[HttpGet("unpublish"), Authorize]
		public async Task<FullInvention?> UnpublishInvention([FromQuery] long inventionId)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.CreatorPlayerId == userId && x.InventionId == inventionId);
			if (invention == null) return null;

			invention.IsPublished = false;

			await db.SaveChangesAsync();

			return await invention.ToFullInvention(db);
		}

		[HttpGet("personaldetails/{inventionId}")]
		public async Task<InventionPersonalDetails?> GetPersonalDetailsForInvention(long inventionId)
		{
			var userId = User.GetUserId();

			var details = await db.InventionPersonalDetails.FirstOrDefaultAsync(x => x.InventionId == inventionId && x.PlayerId == userId);
			if (details == null) return new InventionPersonalDetails { IsCheering = false };

			return details;
		}

		[HttpGet("tagfilters")]
		public RoomFilters? GetTagFilters()
		{
			return new RoomFilters
			{
				PinnedFilters = ["dormskin", "weapon", "certified", "plushie", "scifi", "fantasy", "costume", "art", "character", "environment", "gadget"],
				PopularFilters = ["dormskin", "weapon", "certified", "plushie", "scifi", "fantasy", "costume", "art", "character", "environment", "gadget"],
				TrendingFilters = []
			};
		}

				[HttpGet("dormskinsfromids")]
		public async Task<List<long>> GetDormSkinsFromIds([FromQuery] string[]? ids)
		{
			var parsed = (ids ?? Array.Empty<string>())
				.SelectMany(raw => (raw ?? "").Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
				.Select(part => long.TryParse(part, out var value) ? value : -1)
				.Where(value => value > 0)
				.Distinct()
				.ToList();

			if (parsed.Count == 0) return [];

			var known = await db.Inventions.AsNoTracking()
				.Where(x => parsed.Contains(x.InventionId) && !x.HideFromPlayer)
				.Select(x => x.InventionId)
				.ToListAsync();
			var knownSet = known.ToHashSet();

			return parsed.Where(knownSet.Contains).ToList();
		}

		[HttpGet("featureddormskins")]
		public async Task<List<Invention>> GetFeaturedDormSkins()
		{
			var featured = await db.Inventions.AsNoTracking()
				.Where(x => !x.HideFromPlayer && x.IsPublished)
				.OrderByDescending(x => x.ModifiedAt)
				.Take(24)
				.ToListAsync();

			return featured.Select(x => x.ToInvention()).ToList();
		}

		[HttpGet("version"), Authorize]
		public async Task<InventionVersion?> GetInventionVersion([FromQuery] long inventionId, [FromQuery] int version)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.InventionId == inventionId);
			if (invention == null) return null;

			return await db.GetInventionVersion(version, inventionId);
		}

		[HttpGet("update"), Authorize]
		public async Task<FullInvention?> UpdateInvention([FromQuery] long inventionId, [FromQuery] string? name, [FromQuery] string? imgName, [FromQuery] string? description, [FromQuery] string? permission)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.CreatorPlayerId == userId && x.InventionId == inventionId);
			if (invention == null) return null;

			if (name != null)
				invention.Name = name;
			if (description != null)
				invention.Description = description;
			if (imgName != null)
				invention.ImageName = imgName;

			if (permission != null)
			{
				if (Enum.TryParse<InventionRole>(permission, out var parsedRole))
					invention.GeneralPermission = parsedRole;
			}

			await db.SaveChangesAsync();

			return await invention.ToFullInvention(db);
		}

		[HttpGet("toptoday")]
		public async Task<List<Invention>> GetTopInventions()
		{
			var topInventions = await db.Inventions.Where(x => !x.HideFromPlayer && x.IsPublished)
				.OrderByDescending(x => x.ModifiedAt).ToListAsync();

			var converted = new List<Invention>();
			foreach (var i in topInventions)
			{
				var invention = i.ToInvention();
				converted.Add(invention);
			}

			return converted;
		}

		[HttpGet("featured")]
		public async Task<List<Invention>> GetFeaturedInventions()
		{
			var featured = await db.Inventions
				.Where(x => !x.HideFromPlayer && x.IsPublished)
				.OrderByDescending(x => x.ModifiedAt)
				.Take(24)
				.ToListAsync();

			return featured.Select(x => x.ToInvention()).ToList();
		}

		[HttpPost("settags"), Authorize]
		public async Task<InventionTagResponse?> UpdateInventionTags([FromBody] ModifyInventionTagsRequest req)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.CreatorPlayerId == userId && x.InventionId == req.InventionId);
			if (invention == null) return new InventionTagResponse { Result = RecNet.Enums.InventionTagResult.InventionDoesNotExist };
			if (req.CustomTags.Count >= 10) new InventionTagResponse { Result = RecNet.Enums.InventionTagResult.TooManyTags };

			var tags = new List<ItemTag>();
			foreach (string tag in req.AutoTags)
			{
				tags.Add(new ItemTag { Tag = tag, Type = RecNet.Enums.TagType.Auto });
			}
			foreach (string tag in req.CustomTags)
			{
				tags.Add(new ItemTag { Tag = tag, Type = RecNet.Enums.TagType.General });
			}
			invention.Tags = StringTools.CreateTagString(tags);

			await db.SaveChangesAsync();

			return new InventionTagResponse { Tags = StringTools.TagsToStrings(tags), Result = RecNet.Enums.InventionTagResult.Success };
		}

		[HttpGet("details"), Authorize]
		public async Task<TagResponse?> GetInventionDetails([FromQuery] long inventionId)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.InventionId == inventionId);

			if (invention == null)
				return null;
			if (invention.Tags == null)
				return new TagResponse { Tags = [] };

			return new TagResponse { Tags = StringTools.ReadTags(invention.Tags) };
		}

		[HttpGet("batch"), Authorize]
		public async Task<List<Invention>?> GetBatchInventions([FromBody] List<long> ids)
		{
			var userId = User.GetUserId();

			var inventions = new List<Invention>();

			foreach (var id in ids)
			{
				var invention = await db.Inventions.FirstOrDefaultAsync(x => x.InventionId == id);
				if (invention == null) continue;
				inventions.Add(invention.ToInvention());
			}

			return inventions;
		}

		[HttpGet("fulllineageowner"), Authorize]
		public async Task<bool> OwnsInventionLineage([FromQuery] List<long> id)
		{
			var userId = User.GetUserId();






			var unlocks = await db.Unlocks.AsNoTracking().FirstOrDefaultAsync(x => x.AccountId == userId);
			var bought = new HashSet<long>();
			if (unlocks != null && !string.IsNullOrWhiteSpace(unlocks.Inventions) && unlocks.Inventions != "null")
			{
				try { bought = (unlocks.Inventions.FromJson<List<long>>() ?? new List<long>()).ToHashSet(); }
				catch { }
			}

			bool owns = false;
			foreach (var i in id)
			{
				if (bought.Contains(i))
				{
					owns = true;
					break;
				}

				var invention = await db.Inventions.FirstOrDefaultAsync(x => x.InventionId == i);



				if (invention != null)
					owns = (invention.CreatorPlayerId == userId || invention.GeneralPermission == InventionRole.Publish);

				if (owns) break;
			}

			return owns;
		}

		[HttpGet(""), Authorize]
		public async Task<InventionDB?> GetInventionById([FromQuery] long id)
		{
			var userId = User.GetUserId();

			var invention = await db.Inventions.FirstOrDefaultAsync(x => x.InventionId == id);
			if (invention == null) return null;

			return invention;
		}
	}
}