using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using RadicadeServer.DB;
using RadicadeServer.Extensions;
using RadicadeServer.RecNet.CDN;
using RadicadeServer.RecNet.Enums;
using RadicadeServer.RecNet.Images;
using RadicadeServer.RecNet.Responses;
using RadicadeServer.Radicade.Discord.Templates;

namespace RadicadeServer.API
{
	[Route("api/images")]
	public class ImagesAPI : Controller
	{
		RecDBContext db;
		public ImagesAPI(RecDBContext context)
		{
			this.db = context;
		}


		private static object ToSavedImage(ImageDB image, int cheerCount) => new
		{
			Id = image.Id,
			SavedImageId = image.Id,
			Type = (int)image.ImageType,
			SavedImageType = (int)image.ImageType,
			Accessibility = (int)image.Accessibility,
			AccessibilityLocked = false,
			ImageName = image.Name,
			Description = (string?)null,
			PlayerId = image.OwnerId,
			TaggedPlayerIds = ParseTaggedPlayerIds(image.PlayerIds),
			RoomId = image.RoomId,
			PlayerEventId = image.EventId,
			CreatedAt = image.CreatedAt,
			CheerCount = cheerCount,
			CommentCount = 0
		};

		private static object ToImagesPlayer(ImageDB image, int cheerCount) => new
		{
			SavedImageId = image.Id,
			Id = image.Id,
			SavedImageType = (int)image.ImageType,
			Type = (int)image.ImageType,
			Accessibility = (int)image.Accessibility,
			AccessibilityLocked = false,
			CheerCount = cheerCount,
			CommentCount = 0,
			CreatedAt = image.CreatedAt,
			Description = (string?)null,
			ImageName = image.Name,
			PlayerEventId = image.EventId,
			PlayerId = image.OwnerId,
			RoomId = image.RoomId
		};

		private static List<long> ParseTaggedPlayerIds(string json)
		{
			try
			{
				return string.IsNullOrWhiteSpace(json)
					? new List<long>()
					: (json.FromJson<List<long>>() ?? new List<long>());
			}
			catch
			{
				return new List<long>();
			}
		}

		private async Task<Dictionary<long, int>> CheerCountsAsync(IEnumerable<long> imageIds)
		{
			var ids = imageIds.Distinct().ToList();
			if (ids.Count == 0)
				return new Dictionary<long, int>();

			return await db.ImageInteractions.AsNoTracking()
				.Where(c => c.IsCheered && ids.Contains(c.SavedImageId))
				.GroupBy(c => c.SavedImageId)
				.Select(g => new { g.Key, Count = g.Count() })
				.ToDictionaryAsync(g => g.Key, g => g.Count);
		}

		private static string[] TagMatchPatterns(long playerId) => new[]
		{
			$"[{playerId},", $",{playerId},", $",{playerId}]", $"[{playerId}]"
		};


		[HttpGet("v5/player/{id:long}")]
		public async Task<List<object>> GetImagesFromPlayer(long id, [FromQuery] int sort = 0, [FromQuery] int skip = 0, [FromQuery] int take = 100)
		{
			var images = await db.Images.AsNoTracking()
				.Where(image => image.OwnerId == id && image.Accessibility == SavedImageAccessibility.Public)
				.ToListAsync();

			var cheers = await CheerCountsAsync(images.Select(image => image.Id));
			var ordered = OrderImages(images, sort, cheers)
				.Skip(skip).Take(take)
				.ToList();

			return ordered.Select(image => ToImagesPlayer(image, cheers.GetValueOrDefault(image.Id))).ToList();
		}

		[HttpGet("v4/player/{id:long}")]
		public Task<List<object>> GetImagesFromPlayerV4(long id, [FromQuery] int skip = 0, [FromQuery] int take = 100)
			=> GetImagesFromPlayer(id, 0, skip, take);

		[HttpGet("v4/room/{id}")]
		public async Task<List<object>> GetImagesFromRoom(long? id, [FromQuery] int sort = 0, [FromQuery] int filter = 0, [FromQuery] int skip = 0, [FromQuery] int take = 100)
		{
			var result = new List<object>();
			if (id == null)
				return result;

			var images = await db.Images.AsNoTracking()
				.Where(x => x.RoomId == id && x.Accessibility == SavedImageAccessibility.Public)
				.ToListAsync();

			if (filter > 0)
				images = images.Where(x => (int)x.ImageType == filter).ToList();

			var cheers = await CheerCountsAsync(images.Select(x => x.Id));
			var ordered = OrderImages(images, sort, cheers)
				.Skip(skip).Take(take)
				.ToList();

			return ordered.Select(image => ToSavedImage(image, cheers.GetValueOrDefault(image.Id))).ToList();
		}

		[HttpGet("v1/playerevent/{eventId}")]
		public async Task<List<object>> GetImagesFromEvent(long eventId, [FromQuery] int skip = 0, [FromQuery] int take = 100)
		{
			var images = await db.Images.AsNoTracking()
				.Where(x => x.EventId == eventId && x.Accessibility == SavedImageAccessibility.Public)
				.ToListAsync();

			var cheers = await CheerCountsAsync(images.Select(x => x.Id));
			var ordered = OrderImages(images, 0, cheers)
				.Skip(skip).Take(take)
				.ToList();

			return ordered.Select(image => ToSavedImage(image, cheers.GetValueOrDefault(image.Id))).ToList();
		}

		private static IEnumerable<ImageDB> OrderImages(IEnumerable<ImageDB> images, int sort, Dictionary<long, int> cheers)
		{
			return sort == 1
				? images.OrderByDescending(x => cheers.GetValueOrDefault(x.Id))
					.ThenByDescending(x => x.CreatedAt).ThenByDescending(x => x.Id)
				: images.OrderByDescending(x => x.CreatedAt).ThenByDescending(x => x.Id);
		}


		[HttpGet("v3/feed/player/{id:long}")]
		public async Task<List<object>> GetPlayerFeed(long id, [FromQuery] int skip = 0, [FromQuery] int take = 100)
		{
			var patterns = TagMatchPatterns(id);
			var images = await db.Images.AsNoTracking()
				.Where(x => x.Accessibility == SavedImageAccessibility.Public &&
					(x.OwnerId == id ||
					 x.PlayerIds.Contains(patterns[0]) ||
					 x.PlayerIds.Contains(patterns[1]) ||
					 x.PlayerIds.Contains(patterns[2]) ||
					 x.PlayerIds.Contains(patterns[3])))
				.ToListAsync();

			var cheers = await CheerCountsAsync(images.Select(x => x.Id));
			var ordered = OrderImages(images, 0, cheers)
				.Skip(skip).Take(take)
				.ToList();

			return ordered.Select(image => ToImagesPlayer(image, cheers.GetValueOrDefault(image.Id))).ToList();
		}

		[HttpGet("v3/feed/global")]
		public async Task<object> GetGlobalFeed([FromQuery] int skip = 0, [FromQuery] int take = 100)
		{
			var images = await db.Images.AsNoTracking()
				.Where(x => x.Accessibility == SavedImageAccessibility.Public &&
					x.ImageType == SavedImageType.ShareCamera)
				.OrderByDescending(x => x.CreatedAt).ThenByDescending(x => x.Id)
				.Skip(skip).Take(Math.Clamp(take, 1, 100))
				.ToListAsync();

			var ownerIds = images.Select(x => x.OwnerId).Distinct().ToList();
			var roomIds = images.Where(x => x.RoomId != null).Select(x => x.RoomId!.Value).Distinct().ToList();

			var usernames = await db.Profiles.AsNoTracking()
				.Where(p => ownerIds.Contains(p.accountId))
				.ToDictionaryAsync(p => p.accountId, p => p.username);
			var roomNames = await db.Rooms.AsNoTracking()
				.Where(r => roomIds.Contains(r.RoomId))
				.ToDictionaryAsync(r => r.RoomId, r => r.Name);

			var entries = images.Select(image => new
			{
				SavedImageId = image.Id,
				ImageName = image.Name,
				Username = usernames.TryGetValue(image.OwnerId, out var username) ? username : $"Player{image.OwnerId}",
				RoomName = image.RoomId != null && roomNames.TryGetValue(image.RoomId.Value, out var roomName) ? roomName : (string?)null,
				RoomId = image.RoomId,
				SavedImageType = (int)image.ImageType,
				PlayerEventId = image.EventId,
				Accessibility = (int)image.Accessibility,
				PlayerIds = ParseTaggedPlayerIds(image.PlayerIds)
			}).ToList();

			return new { Images = entries, ValidTill = DateTime.UtcNow.AddMinutes(2) };
		}

		[HttpGet("v3/bulk")]
		public async Task<List<object>> GetBulkImages([FromQuery] string ids)
		{
			var result = new List<object>();
			if (string.IsNullOrWhiteSpace(ids))
				return result;

			var parsed = ids
				.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
				.Select(part => long.TryParse(part, out var value) ? value : -1)
				.Where(value => value > 0)
				.ToList();
			if (parsed.Count == 0)
				return result;

			var images = await db.Images.AsNoTracking()
				.Where(x => parsed.Contains(x.Id) && x.Accessibility == SavedImageAccessibility.Public)
				.ToListAsync();
			var byId = images.ToDictionary(x => x.Id);
			var cheers = await CheerCountsAsync(images.Select(x => x.Id));

			foreach (var id in parsed)
			{
				if (byId.TryGetValue(id, out var image))
					result.Add(ToSavedImage(image, cheers.GetValueOrDefault(image.Id)));
			}
			return result;
		}

		[HttpGet("v4/{photoId:long}")]
		public async Task<IActionResult> GetImageById(long photoId)
		{
			var image = await db.Images.AsNoTracking().FirstOrDefaultAsync(x => x.Id == photoId);
			if (image == null)
				return NotFound();





			if (image.Accessibility == SavedImageAccessibility.Private)
				return NotFound();
			return Ok(ToSavedImage(image, await db.ImageInteractions.AsNoTracking()
				.CountAsync(c => c.SavedImageId == image.Id && c.IsCheered)));
		}

		[HttpGet("v5/bulk")]
		public async Task<List<object>> GetBulkImageMetadata([FromQuery] string[]? ids)
		{
			var result = new List<object>();
			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 result;

			var images = await db.Images.AsNoTracking()
				.Where(x => parsed.Contains(x.Id) && x.Accessibility == SavedImageAccessibility.Public)
				.ToListAsync();
			var byId = images.ToDictionary(x => x.Id);
			var cheers = await CheerCountsAsync(images.Select(x => x.Id));

			foreach (var id in parsed)
			{
				if (byId.TryGetValue(id, out var image))
					result.Add(ToBulkSavedImage(image, cheers.GetValueOrDefault(image.Id)));
			}
			return result;
		}

		private static object ToBulkSavedImage(ImageDB image, int cheerCount) => new
		{
			Id = image.Id,
			Type = (int)image.ImageType,
			Accessibility = (int)image.Accessibility,
			AccessibilityLocked = false,
			ImageName = image.Name,
			Description = (string?)null,
			PlayerId = image.OwnerId,
			TaggedPlayerIds = ParseTaggedPlayerIds(image.PlayerIds),
			RoomId = image.RoomId,
			PlayerEventId = image.EventId,
			CreatedAt = image.CreatedAt,
			CheerCount = cheerCount,
			CommentCount = 0,
			SavedImageId = image.Id,
			SavedImageType = (int)image.ImageType,
			ClubId = 0
		};

		[HttpGet("v6")]
		public async Task<IActionResult> GetImageByName([FromQuery] string name)
		{
			if (string.IsNullOrWhiteSpace(name))
				return BadRequest(new { error = "name is required" });

			var image = await db.Images.AsNoTracking().FirstOrDefaultAsync(x => x.Name == name);
			if (image == null)
				return NotFound();



			if (image.Accessibility == SavedImageAccessibility.Private)
				return NotFound();

			var viewerId = User.GetUserId() ?? Request.Headers.Authorization.ToString().GetUserId();
			if (viewerId != null)
				RecentImageReferences.Remember(viewerId.Value, image.Id);

			return Ok(new
			{
				SavedImageId = image.Id,
				ImageName = image.Name,
				PlayerId = image.OwnerId,
				RoomId = image.RoomId ?? 0,
				PlayerEventId = image.EventId ?? 0,
				ClubId = 0,
				Description = "",
				Accessibility = (int)image.Accessibility,
				AccessibilityLocked = false,
				SavedImageType = (int)image.ImageType,
				CreatedAt = image.CreatedAt,
				CheerCount = await db.ImageInteractions.AsNoTracking()
					.CountAsync(c => c.SavedImageId == image.Id && c.IsCheered),
				CommentCount = 0
			});
		}


		[HttpPost("v1/cheer"), Authorize]
		public async Task<Success> CheerImage([FromBody] ImageCheerRequest req)
		{
			var userId = User.GetUserId();
			if (userId == null)
				return new Success(false, "Not signed in", null);

			var existingInteraction = await db.ImageInteractions.FirstOrDefaultAsync(x =>
				x.PlayerId == userId && x.SavedImageId == req.SavedImageId);
			if (existingInteraction != null)
				existingInteraction.IsCheered = req.Cheer;
			else
				await db.ImageInteractions.AddAsync(
					new CheeredImage { IsCheered = req.Cheer, PlayerId = (long)userId, SavedImageId = req.SavedImageId }
				);

			await db.SaveChangesAsync();

			return new Success(true, null, null);
		}

		[HttpGet("v1/{imageId:long}/cheers")]
		public async Task<List<long>> GetImageCheers(long imageId)
		{
			return await db.ImageInteractions.AsNoTracking()
				.Where(x => x.SavedImageId == imageId && x.IsCheered)
				.Select(x => x.PlayerId)
				.ToListAsync();
		}

		[HttpGet("v2/named")]
		public List<NamedImage> GetNamedImages()
		{
			var config = db.ServerConfig.FirstOrDefault(x => x.Key == "NamedImages");
			return config?.Value.FromJson<List<NamedImage>>() ?? new List<NamedImage>();
		}

		private async Task<List<object>> CheerLookup(List<long> ids)
		{
			var userId = User.GetUserId();
			if (userId == null)
				return new List<object>();

			ids ??= new List<long>();
			var cheeredIds = await db.ImageInteractions.AsNoTracking()
				.Where(x => x.PlayerId == userId && x.IsCheered && ids.Contains(x.SavedImageId))
				.Select(x => x.SavedImageId)
				.ToListAsync();
			var cheeredSet = cheeredIds.ToHashSet();

			return ids.Select(id => (object)new { SavedImageId = id, IsCheered = cheeredSet.Contains(id) }).ToList();
		}

		[HttpGet("v5/cheered/bulk"), Authorize]
		public Task<List<object>> GetBulkImageCheers([FromQuery] long[] id)
			=> CheerLookup((id ?? Array.Empty<long>()).ToList());

		[HttpPost("v5/cheered/bulk"), Authorize]
		public async Task<List<object>> PostBulkImageCheers()
		{
			var ids = new List<long>();
			if (Request.HasFormContentType)
			{
				var form = await Request.ReadFormAsync();
				foreach (var value in form["id"])
				{
					if (long.TryParse(value, out var parsed))
						ids.Add(parsed);
				}
			}
			return await CheerLookup(ids);
		}


		[HttpPost("v1/{imageId:long}/report"), Authorize]
		public async Task<IActionResult> ReportImage(long imageId)
		{
			await Task.CompletedTask;
			return Ok(new { success = true });
		}

		[HttpPost("v1/{imageId:long}/player/{playerId:long}/untag"), Authorize]
		public async Task<IActionResult> UntagFromImage(long imageId, long playerId)
		{
			var userId = User.GetUserId();

			var image = await db.Images.FirstOrDefaultAsync(x => x.Id == imageId);
			if (image == null)
				return NotFound();

			if (userId != playerId && userId != image.OwnerId)
				return StatusCode(403);

			var tagged = ParseTaggedPlayerIds(image.PlayerIds);
			if (!tagged.Remove(playerId))
				return Ok(new { success = true });

			image.PlayerIds = tagged.ToJson();
			await db.SaveChangesAsync();
			return Ok(new { success = true });
		}


		[HttpPost("v4/uploadsaved"), Authorize]
		public async Task<ActionResult<ImageNameDTO?>> UploadSavedImage([FromForm] IFormFile? image, [FromForm] SavedImageMetaDTO? imgMeta)
		{
			if (imgMeta == null)
				return BadRequest();
			if (image == null || image.Length <= 0 || image.Length >= 2 * 1024 * 1024)
				return StatusCode(413);

			var userId = User.GetUserId();
			if (userId == null)
				return Unauthorized();

			var presence = await db.Presences.FirstOrDefaultAsync(x => x.playerId == userId);
			var roomInstance = presence != null
				? await db.RoomInstances.FirstOrDefaultAsync(x => x.roomInstanceId == presence.roomInstance)
				: null;

			string imageName = Guid.NewGuid().ToString() + ".png";
			string path = Path.Join(DBConfig.CDNImages, imageName);

			using (var stream = new FileStream(path, FileMode.Create))
			{
				await image.CopyToAsync(stream);
			}

			SavedImageAccessibility accessibility = imgMeta.accessibility;
			if (imgMeta.savedImageType == SavedImageType.InventionThumbnail ||
				imgMeta.savedImageType == SavedImageType.OutfitThumbnail ||
				imgMeta.savedImageType == SavedImageType.ProfileThumbnail ||
				imgMeta.savedImageType == SavedImageType.RoomThumbnail)
			{
				accessibility = SavedImageAccessibility.Private;
			}

			var taggedPlayerIds = (imgMeta.playerIds ?? new List<long>())
				.Where(id => id > 0)
				.Distinct()
				.ToList();

			var savedImage = new ImageDB { CreatedAt = DateTime.Now, Name = imageName, OwnerId = (long)userId, Accessibility = accessibility, ImageType = imgMeta.savedImageType, RoomId = imgMeta.roomId ?? roomInstance?.roomId, EventId = imgMeta.playerEventId, PlayerIds = taggedPlayerIds.ToJson() };
			await db.Images.AddAsync(savedImage);
			await db.SaveChangesAsync();

			RecentImageReferences.Remember((long)userId, savedImage.Id);

			if (imgMeta.savedImageType == SavedImageType.ProfileThumbnail)
			{
				var profile = await db.Profiles.FirstOrDefaultAsync(x => x.accountId == userId);
				if (profile != null)
				{
					profile.profileImage = imageName;
					await db.SaveChangesAsync();
				}
			}

			if (accessibility == SavedImageAccessibility.Public || imgMeta.savedImageType == SavedImageType.ShareCamera)
			{
				var room = await db.Rooms.AsNoTracking().FirstOrDefaultAsync(x => x.RoomId == imgMeta.roomId);
				var ownerProfile = await db.Profiles.AsNoTracking().FirstOrDefaultAsync(x => x.accountId == userId);

				string? roomName = null;

				if (ownerProfile != null)
				{
					if (room != null)
					{
						if (room.Accessibility >= Accessibility.Public)
							roomName = "^" + room.Name;
						else if (room.IsDorm && roomInstance != null)
							roomName = roomInstance?.name;
						else
							roomName = "[PRIVATE]";
					}

					await WebhookImageUpload.Send($"{DBConfig.NameServer.Images}/img/{imageName}", ownerProfile.username, ownerProfile.displayName, $"{DBConfig.NameServer.Images}/img/{ownerProfile.profileImage}", roomName);
				}
			}

			return new ImageNameDTO { ImageName = imageName };
		}

		[HttpDelete("v1/deletesaved"), Authorize]
		[HttpPost("v1/deletesaved"), Authorize]
		public async Task<IActionResult> DeleteSavedImage()
		{
			var userId = User.GetUserId();
			string? imageName = null;

			if (Request.HasFormContentType)
			{
				var form = await Request.ReadFormAsync();
				imageName = form["ImageName"].ToString();
				if (string.IsNullOrWhiteSpace(imageName))
					imageName = form["imageName"].ToString();
			}
			else
			{
				try
				{
					using var doc = await System.Text.Json.JsonDocument.ParseAsync(Request.Body);
					if (doc.RootElement.ValueKind == System.Text.Json.JsonValueKind.Object &&
						doc.RootElement.TryGetProperty("ImageName", out var prop) &&
						prop.ValueKind == System.Text.Json.JsonValueKind.String)
						imageName = prop.GetString();
				}
				catch (System.Text.Json.JsonException) { }
			}

			if (string.IsNullOrWhiteSpace(imageName))
				return BadRequest(new { error = "ImageName is required" });

			var image = await db.Images.FirstOrDefaultAsync(x => x.Name == imageName);
			if (image == null)
				return NotFound();
			if (image.OwnerId != userId)
				return StatusCode(403, new { error = "Not your image" });

			var cheers = db.ImageInteractions.Where(x => x.SavedImageId == image.Id);
			db.ImageInteractions.RemoveRange(cheers);
			db.Images.Remove(image);
			await db.SaveChangesAsync();

			var fullPath = Path.Join(DBConfig.CDNImages, imageName);
			if (System.IO.File.Exists(fullPath))
				System.IO.File.Delete(fullPath);

			return Ok(new { success = true });
		}
	}
}