using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Dalamud.Bindings.ImGui;
using Dalamud.Interface;
using Dalamud.Interface.Utility.Raii;
using Dalamud.Plugin;
using Dalamud.Plugin.Services;
using FFXIVClientStructs.FFXIV.Client.Game;
using LLib.GameData;
using Lumina.Excel;
using Lumina.Excel.Sheets;
using Questionable.Controller;
using Questionable.Model;
using Questionable.Model.Gathering;

namespace Questionable.Windows.JournalComponents;

internal sealed class GatheringJournalComponent
{
	private enum RowType : byte
	{
		Expansion,
		Territory,
		GatheringPoint,
		Item
	}

	private readonly record struct GatheringCounts(string FormattedSupported, string FormattedCollected, bool IsSupportedComplete, bool IsCollectedComplete, bool IsSupportedEmpty, bool IsCollectedEmpty)
	{
		public static GatheringCounts Empty => new GatheringCounts("-", "-", IsSupportedComplete: false, IsCollectedComplete: false, IsSupportedEmpty: true, IsCollectedEmpty: true);

		private static readonly int PadWidth = 9999.ToString(CultureInfo.CurrentCulture).Length;

		public static GatheringCounts Create(int supported, int totalSupported, int collected, int totalCollected)
		{
			return new GatheringCounts(FormatPair(supported, totalSupported), FormatPair(collected, totalCollected), supported == totalSupported && totalSupported > 0, collected == totalCollected && totalCollected > 0, totalSupported == 0, totalCollected == 0);
		}

		private static string FormatPair(int n, int d)
		{
			if (d != 0)
			{
				return n.ToString(CultureInfo.CurrentCulture).PadLeft(PadWidth) + " / " + d.ToString(CultureInfo.CurrentCulture).PadLeft(PadWidth);
			}
			return "-".PadLeft(PadWidth) + " / " + "-".PadLeft(PadWidth);
		}
	}

	private readonly record struct FlatRow(RowType Type, int Depth, int GroupIndex, string Label, GatheringCounts Counts, bool IsPointComplete, ushort ItemId, bool IsItemGathered);

	private delegate byte GetIsGatheringItemGatheredDelegate(ushort item);

	private sealed record ExpansionPoints(EExpansionVersion ExpansionVersion, List<TerritoryPoints> PointsByTerritories)
	{
		public int TotalItems { get; set; }

		public int TotalPoints { get; set; }

		public int CompletedItems { get; set; }

		public int CompletedPoints { get; set; }
	}

	private sealed record TerritoryPoints(ushort TerritoryType, string TerritoryName, List<DefaultGatheringPoint> Points)
	{
		public int TotalItems { get; set; }

		public int TotalPoints => Points.Count;

		public int CompletedItems { get; set; }

		public int CompletedPoints { get; set; }

		public string ToFriendlyString()
		{
			if (string.IsNullOrEmpty(TerritoryName))
			{
				return $"??? ({TerritoryType})";
			}
			return TerritoryName;
		}
	}

	private sealed record DefaultGatheringPoint(GatheringPointId Id, EClassJob ClassJob, byte Level, List<ushort> GatheringItemIds, EExpansionVersion Expansion, ushort TerritoryType, string? TerritoryName, string? PlaceName)
	{
		public int TotalItems { get; set; }

		public int CompletedItems { get; set; }

		public bool IsComplete { get; set; }
	}

	private sealed record FilteredExpansion(ExpansionPoints Expansion, List<FilteredTerritory> Territories);

	private sealed record FilteredTerritory(TerritoryPoints Territory, List<FilteredGatheringPoint> GatheringPoints);

	private sealed record FilteredGatheringPoint(DefaultGatheringPoint Point, List<ushort> GatheringItemIds);

	private readonly IDalamudPluginInterface _pluginInterface;

	private readonly UiUtils _uiUtils;

	private readonly GatheringPointRegistry _gatheringPointRegistry;

	private readonly Dictionary<int, string> _gatheringItems;

	private readonly List<ExpansionPoints> _gatheringPointsByExpansion;

	private readonly List<ushort> _gatheredItems = new List<ushort>();

	private List<FilteredExpansion> _filteredExpansions = new List<FilteredExpansion>();

	private List<FlatRow> _flatRows = new List<FlatRow>();

	private readonly HashSet<(RowType Type, int GroupIndex)> _expandedGroups = new HashSet<(RowType, int)>();

	private string _searchText = string.Empty;

	private static bool IsGatheringItemGathered(uint item)
	{
		return QuestManager.IsGatheringItemGathered((ushort)item);
	}

	public GatheringJournalComponent(IDataManager dataManager, IDalamudPluginInterface pluginInterface, UiUtils uiUtils, IGameInteropProvider gameInteropProvider, GatheringPointRegistry gatheringPointRegistry)
	{
		GatheringJournalComponent gatheringJournalComponent = this;
		_pluginInterface = pluginInterface;
		_uiUtils = uiUtils;
		_gatheringPointRegistry = gatheringPointRegistry;
		Dictionary<uint, List<uint>> routeToGatheringPoint = (from x in (from x in dataManager.GetExcelSheet<GatheringLeveRoute>()
				where x.GatheringPoint[0].RowId != 0
				select x).SelectMany((GatheringLeveRoute x) => from y in x.GatheringPoint
				where y.RowId != 0
				select new
				{
					RouteId = x.RowId,
					GatheringPointId = y.RowId
				})
			group x by x.RouteId).ToDictionary(x => x.Key, x => x.Select(y => y.GatheringPointId).ToList());
		ExcelSheet<GatheringLeve> gatheringLeveSheet = dataManager.GetExcelSheet<GatheringLeve>();
		ExcelSheet<TerritoryType> territoryTypeSheet = dataManager.GetExcelSheet<TerritoryType>();
		HashSet<uint> leveGatheringPoints = (from y in (from x in dataManager.GetExcelSheet<Leve>()
				where x.RowId != 0
				select gatheringLeveSheet.GetRowOrDefault(x.DataId.RowId) into x
				where x.HasValue
				select x).Cast<GatheringLeve>().SelectMany((GatheringLeve x) => x.Route)
			where y.RowId != 0
			select y).SelectMany((RowRef<GatheringLeveRoute> y) => routeToGatheringPoint[y.RowId]).Distinct().ToHashSet();
		ExcelSheet<Item> itemSheet = dataManager.GetExcelSheet<Item>();
		_gatheringItems = (from x in dataManager.GetExcelSheet<GatheringItem>()
			where x.RowId != 0 && x.GatheringItemLevel.RowId != 0
			select new
			{
				GatheringItemId = (int)x.RowId,
				Name = itemSheet.GetRowOrDefault(x.Item.RowId)?.Name.ToString()
			} into x
			where !string.IsNullOrEmpty(x.Name)
			select x).ToDictionary(x => x.GatheringItemId, x => x.Name);
		_gatheringPointsByExpansion = (from x in (from DefaultGatheringPoint x in from x in (from x in (from x in dataManager.GetExcelSheet<GatheringPoint>()
							where x.GatheringPointBase.RowId != 0
							select x).Where(delegate(GatheringPoint x)
						{
							uint rowId = x.GatheringPointBase.RowId;
							return (rowId < 653 || rowId > 680) ? true : false;
						}).DistinctBy((GatheringPoint x) => x.GatheringPointBase.RowId).Select(delegate(GatheringPoint x)
						{
							uint rowId = x.RowId;
							GatheringPointId id = new GatheringPointId((ushort)x.GatheringPointBase.RowId);
							EClassJob classJob;
							switch (x.GatheringPointBase.Value.GatheringType.RowId)
							{
							case 0u:
							case 1u:
								classJob = EClassJob.Miner;
								break;
							case 2u:
							case 3u:
								classJob = EClassJob.Botanist;
								break;
							default:
								classJob = EClassJob.Fisher;
								break;
							}
							return new
							{
								GatheringPointId = rowId,
								Point = new DefaultGatheringPoint(id, classJob, x.GatheringPointBase.Value.GatheringLevel, (from y in x.GatheringPointBase.Value.Item
									where y.RowId != 0
									select (ushort)y.RowId).ToList(), (EExpansionVersion)(((byte?)x.TerritoryType.ValueNullable?.ExVersion.RowId) ?? byte.MaxValue), (ushort)x.TerritoryType.RowId, x.TerritoryType.ValueNullable?.PlaceName.ValueNullable?.Name.ToString(), $"{x.GatheringPointBase.RowId} - {x.PlaceName.ValueNullable?.Name}")
							};
						})
						where x.Point.ClassJob != EClassJob.Fisher
						select x).Select(x =>
					{
						if (leveGatheringPoints.Contains(x.GatheringPointId))
						{
							return (DefaultGatheringPoint)null;
						}
						if (x.Point.TerritoryType == 1 && gatheringJournalComponent._gatheringPointRegistry.TryGetGatheringPoint(x.Point.Id, out GatheringRoot gatheringRoot))
						{
							TerritoryType row = territoryTypeSheet.GetRow(gatheringRoot.Steps.Last().TerritoryId);
							return x.Point with
							{
								Expansion = (EExpansionVersion)row.ExVersion.RowId,
								TerritoryType = (ushort)row.RowId,
								TerritoryName = row.PlaceName.ValueNullable?.Name.ToString()
							};
						}
						return x.Point;
					})
					where x != null
					select x
				where x.Expansion != (EExpansionVersion)255
				where x.GatheringItemIds.Count > 0
				select x).Where(delegate(DefaultGatheringPoint x)
			{
				ushort territoryType = x.TerritoryType;
				return territoryType != 901 && territoryType != 929;
			})
			group x by x.Expansion into x
			select new ExpansionPoints(x.Key, (from y in x
				group y by new
				{
					TerritoryType = y.TerritoryType,
					TerritoryName = $"{((!string.IsNullOrEmpty(y.TerritoryName)) ? y.TerritoryName : "???")} ({y.TerritoryType})"
				} into y
				select new TerritoryPoints(y.Key.TerritoryType, y.Key.TerritoryName, y.ToList()) into y
				where y.Points.Count > 0
				select y).ToList()) into x
			orderby x.ExpansionVersion
			select x).ToList();
		gameInteropProvider.InitializeFromAttributes(this);
	}

	public unsafe void DrawGatheringItems()
	{
		if (UiThemeUtils.SearchInput("##GatheringSearch", ref _searchText, -1E-45f, "Search areas, gathering points and items"))
		{
			UpdateFilter();
		}
		ImGui.Separator();
		if (_flatRows.Count > 0)
		{
			float x;
			using (_pluginInterface.UiBuilder.IconFontFixedWidthHandle.Push())
			{
				x = ImGui.CalcTextSize(FontAwesomeIcon.Check.ToIconString()).X;
			}
			float fontGlobalScale = ImGui.GetIO().FontGlobalScale;
			using ImRaii.TableDisposable tableDisposable = UiThemeUtils.BeginThemedTable("GatheringPoints", 3, ImGuiTableFlags.NoSavedSettings | ImGuiTableFlags.ScrollY);
			if (!tableDisposable)
			{
				return;
			}
			ImGui.TableSetupColumn("Name", ImGuiTableColumnFlags.NoHide);
			ImGui.TableSetupColumn("Supported", ImGuiTableColumnFlags.WidthFixed, 120f * fontGlobalScale);
			ImGui.TableSetupColumn("Collected", ImGuiTableColumnFlags.WidthFixed, 120f * fontGlobalScale);
			ImGui.TableHeadersRow();
			float textLineHeightWithSpacing = ImGui.GetTextLineHeightWithSpacing();
			bool flag = false;
			ImGuiListClipper* intPtr = ImGuiNative.ImGuiListClipper();
			ImGuiNative.Begin(intPtr, _flatRows.Count, textLineHeightWithSpacing);
			ImGuiListClipperPtr imGuiListClipperPtr = intPtr;
			try
			{
				while (imGuiListClipperPtr.Step())
				{
					for (int i = imGuiListClipperPtr.DisplayStart; i < imGuiListClipperPtr.DisplayEnd; i++)
					{
						if (DrawFlatRow(_flatRows[i], x))
						{
							flag = true;
						}
					}
				}
			}
			finally
			{
				imGuiListClipperPtr.Destroy();
			}
			if (flag)
			{
				RebuildFlatRows();
			}
			return;
		}
		UiThemeUtils.EmptyState(FontAwesomeIcon.Leaf, "No area, gathering point or item matches your search text.");
	}

	private bool DrawFlatRow(FlatRow row, float iconSpacing)
	{
		ImGui.TableNextRow();
		ImGui.TableNextColumn();
		bool result = false;
		float num = (float)row.Depth * ImGui.GetStyle().IndentSpacing;
		if (row.Type == RowType.Item)
		{
			ImGui.SetCursorPosX(ImGui.GetCursorPosX() + num);
			ImGui.TreeNodeEx(row.Label, ImGuiTreeNodeFlags.NoTreePushOnOpen | ImGuiTreeNodeFlags.Leaf | ImGuiTreeNodeFlags.SpanFullWidth);
			ImGui.TableNextColumn();
			ImGui.TableNextColumn();
			float num2 = ImGui.GetColumnWidth() / 2f - iconSpacing;
			ImGui.SetCursorPosX(ImGui.GetCursorPosX() + num2);
			if (row.ItemId < 10000)
			{
				_uiUtils.ChecklistItem(string.Empty, row.IsItemGathered);
			}
			else
			{
				_uiUtils.ChecklistItem(string.Empty, UiThemeUtils.StatusUnobtainable, FontAwesomeIcon.Minus);
			}
		}
		else if (row.Type == RowType.GatheringPoint)
		{
			(RowType, int) item = (row.Type, row.GroupIndex);
			bool flag = _expandedGroups.Contains(item);
			ImGui.SetCursorPosX(ImGui.GetCursorPosX() + num);
			UiThemeUtils.DrawTrackerGroupCaret(_pluginInterface.UiBuilder.IconFontFixedWidthHandle, flag);
			ImGui.SameLine();
			ImU8String label = new ImU8String(6, 3);
			label.AppendFormatted(row.Label);
			label.AppendLiteral("##grp");
			label.AppendFormatted(row.Type);
			label.AppendLiteral("_");
			label.AppendFormatted(row.GroupIndex);
			if (ImGui.Selectable(label))
			{
				if (flag)
				{
					_expandedGroups.Remove(item);
				}
				else
				{
					_expandedGroups.Add(item);
				}
				result = true;
			}
			ImGui.TableNextColumn();
			float num3 = ImGui.GetColumnWidth() / 2f - iconSpacing;
			ImGui.SetCursorPosX(ImGui.GetCursorPosX() + num3);
			_uiUtils.ChecklistItem(string.Empty, row.IsPointComplete);
			ImGui.TableNextColumn();
			UiThemeUtils.DrawTrackerCount(row.Counts.FormattedCollected, row.Counts.IsCollectedComplete, row.Counts.IsCollectedEmpty);
		}
		else
		{
			(RowType, int) item2 = (row.Type, row.GroupIndex);
			bool flag2 = _expandedGroups.Contains(item2);
			ImGui.SetCursorPosX(ImGui.GetCursorPosX() + num);
			UiThemeUtils.DrawTrackerGroupCaret(_pluginInterface.UiBuilder.IconFontFixedWidthHandle, flag2);
			ImGui.SameLine();
			ImU8String label2 = new ImU8String(6, 3);
			label2.AppendFormatted(row.Label);
			label2.AppendLiteral("##grp");
			label2.AppendFormatted(row.Type);
			label2.AppendLiteral("_");
			label2.AppendFormatted(row.GroupIndex);
			if (ImGui.Selectable(label2))
			{
				if (flag2)
				{
					_expandedGroups.Remove(item2);
				}
				else
				{
					_expandedGroups.Add(item2);
				}
				result = true;
			}
			ImGui.TableNextColumn();
			UiThemeUtils.DrawTrackerCount(row.Counts.FormattedSupported, row.Counts.IsSupportedComplete, row.Counts.IsSupportedEmpty);
			ImGui.TableNextColumn();
			UiThemeUtils.DrawTrackerCount(row.Counts.FormattedCollected, row.Counts.IsCollectedComplete, row.Counts.IsCollectedEmpty);
		}
		return result;
	}

	private void RebuildFlatRows()
	{
		List<FlatRow> list = new List<FlatRow>();
		foreach (FilteredExpansion filteredExpansion in _filteredExpansions)
		{
			ExpansionPoints expansion = filteredExpansion.Expansion;
			int expansionVersion = (int)expansion.ExpansionVersion;
			GatheringCounts counts = GatheringCounts.Create(expansion.CompletedPoints, expansion.TotalPoints, expansion.CompletedItems, expansion.TotalItems);
			list.Add(new FlatRow(RowType.Expansion, 0, expansionVersion, expansion.ExpansionVersion.ToFriendlyString(), counts, IsPointComplete: false, 0, IsItemGathered: false));
			if (!_expandedGroups.Contains((RowType.Expansion, expansionVersion)))
			{
				continue;
			}
			foreach (FilteredTerritory territory2 in filteredExpansion.Territories)
			{
				TerritoryPoints territory = territory2.Territory;
				int territoryType = territory.TerritoryType;
				GatheringCounts counts2 = GatheringCounts.Create(territory.CompletedPoints, territory.TotalPoints, territory.CompletedItems, territory.TotalItems);
				list.Add(new FlatRow(RowType.Territory, 1, territoryType, territory.ToFriendlyString(), counts2, IsPointComplete: false, 0, IsItemGathered: false));
				if (!_expandedGroups.Contains((RowType.Territory, territoryType)))
				{
					continue;
				}
				foreach (FilteredGatheringPoint gatheringPoint in territory2.GatheringPoints)
				{
					DefaultGatheringPoint point = gatheringPoint.Point;
					int value = point.Id.Value;
					GatheringCounts counts3 = GatheringCounts.Create(0, 0, point.CompletedItems, point.TotalItems);
					list.Add(new FlatRow(RowType.GatheringPoint, 2, value, $"{point.PlaceName} ({point.ClassJob} Lv. {point.Level})", counts3, point.IsComplete, 0, IsItemGathered: false));
					if (!_expandedGroups.Contains((RowType.GatheringPoint, value)))
					{
						continue;
					}
					foreach (ushort gatheringItemId in gatheringPoint.GatheringItemIds)
					{
						string valueOrDefault = _gatheringItems.GetValueOrDefault(gatheringItemId, "???");
						bool isItemGathered = _gatheredItems.Contains(gatheringItemId);
						list.Add(new FlatRow(RowType.Item, 3, 0, valueOrDefault, default(GatheringCounts), IsPointComplete: false, gatheringItemId, isItemGathered));
					}
				}
			}
		}
		_flatRows = list;
	}

	public void UpdateFilter()
	{
		Predicate<string> match;
		if (string.IsNullOrWhiteSpace(_searchText))
		{
			match = (string _) => true;
		}
		else
		{
			match = (string x) => x.Contains(_searchText, StringComparison.CurrentCultureIgnoreCase);
		}
		_filteredExpansions = (from section in _gatheringPointsByExpansion
			select FilterExpansion(section, match) into x
			where x != null
			select x).Cast<FilteredExpansion>().ToList();
		RebuildFlatRows();
	}

	private FilteredExpansion? FilterExpansion(ExpansionPoints expansion, Predicate<string> match)
	{
		List<FilteredTerritory> list = (from x in expansion.PointsByTerritories
			select FilterTerritory(x, match) into x
			where x != null
			select (x)).ToList();
		if (list.Count > 0)
		{
			return new FilteredExpansion(expansion, list);
		}
		return null;
	}

	private FilteredTerritory? FilterTerritory(TerritoryPoints territory, Predicate<string> match)
	{
		if (match(territory.TerritoryName))
		{
			return new FilteredTerritory(territory, territory.Points.Select((DefaultGatheringPoint x) => FilterGatheringPoint(x, (string _) => true)).ToList());
		}
		List<FilteredGatheringPoint> list = (from x in territory.Points
			select FilterGatheringPoint(x, match) into x
			where x != null
			select (x)).ToList();
		if (list.Count > 0)
		{
			return new FilteredTerritory(territory, list);
		}
		return null;
	}

	private FilteredGatheringPoint? FilterGatheringPoint(DefaultGatheringPoint gatheringPoint, Predicate<string> match)
	{
		if (match(gatheringPoint.PlaceName ?? string.Empty))
		{
			return new FilteredGatheringPoint(gatheringPoint, gatheringPoint.GatheringItemIds);
		}
		List<ushort> list = gatheringPoint.GatheringItemIds.Where((ushort x) => match(_gatheringItems.GetValueOrDefault(x, string.Empty))).ToList();
		if (list.Count > 0)
		{
			return new FilteredGatheringPoint(gatheringPoint, list);
		}
		return null;
	}

	internal void RefreshCounts()
	{
		_gatheredItems.Clear();
		foreach (int key in _gatheringItems.Keys)
		{
			ushort item = (ushort)key;
			if (IsGatheringItemGathered(item))
			{
				_gatheredItems.Add(item);
			}
		}
		foreach (ExpansionPoints item2 in _gatheringPointsByExpansion)
		{
			foreach (TerritoryPoints pointsByTerritory in item2.PointsByTerritories)
			{
				foreach (DefaultGatheringPoint point in pointsByTerritory.Points)
				{
					point.TotalItems = point.GatheringItemIds.Count((ushort x) => x < 10000);
					point.CompletedItems = point.GatheringItemIds.Count(_gatheredItems.Contains);
					point.IsComplete = _gatheringPointRegistry.TryGetGatheringPoint(point.Id, out GatheringRoot _);
				}
				pointsByTerritory.TotalItems = pointsByTerritory.Points.Sum((DefaultGatheringPoint x) => x.TotalItems);
				pointsByTerritory.CompletedItems = pointsByTerritory.Points.Sum((DefaultGatheringPoint x) => x.CompletedItems);
				pointsByTerritory.CompletedPoints = pointsByTerritory.Points.Count((DefaultGatheringPoint x) => x.IsComplete);
			}
			item2.TotalItems = item2.PointsByTerritories.Sum((TerritoryPoints x) => x.TotalItems);
			item2.CompletedItems = item2.PointsByTerritories.Sum((TerritoryPoints x) => x.CompletedItems);
			item2.TotalPoints = item2.PointsByTerritories.Sum((TerritoryPoints x) => x.TotalPoints);
			item2.CompletedPoints = item2.PointsByTerritories.Sum((TerritoryPoints x) => x.CompletedPoints);
		}
		RebuildFlatRows();
	}

	public void ClearCounts(int type, int code)
	{
		foreach (ExpansionPoints item in _gatheringPointsByExpansion)
		{
			item.CompletedItems = 0;
			item.CompletedPoints = 0;
			foreach (TerritoryPoints pointsByTerritory in item.PointsByTerritories)
			{
				pointsByTerritory.CompletedItems = 0;
				pointsByTerritory.CompletedPoints = 0;
				foreach (DefaultGatheringPoint point in pointsByTerritory.Points)
				{
					point.IsComplete = false;
				}
			}
		}
		RebuildFlatRows();
	}
}