using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AskaPresetSaver.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+91ff6e46d0d62bf196bf09f71f08f796e81a0034")]
[assembly: AssemblyProduct("AskaPresetSaver.Core")]
[assembly: AssemblyTitle("AskaPresetSaver.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace AskaPresetSaver.Core
{
	public sealed class PresetLibraryDto
	{
		public int SchemaVersion { get; set; } = 1;

		public List<SchedulePresetDto> Schedules { get; set; } = new List<SchedulePresetDto>();

		public List<TasksPresetDto> Tasks { get; set; } = new List<TasksPresetDto>();

		public List<EquipColorPresetDto> EquipmentColors { get; set; } = new List<EquipColorPresetDto>();
	}
	public sealed class SchedulePresetDto
	{
		public string Name { get; set; } = "";

		public int[] Schedule { get; set; } = Array.Empty<int>();
	}
	public sealed class TasksPresetDto
	{
		public string Name { get; set; } = "";

		public int TemplateId { get; set; }

		public List<TaskRowDto> Rows { get; set; } = new List<TaskRowDto>();
	}
	public sealed class TaskRowDto
	{
		public int ItemId { get; set; }

		public int Priority { get; set; }

		public float QuantityRatio { get; set; }
	}
	public sealed class EquipColorPresetDto
	{
		public string Name { get; set; } = "";

		public int[] DyeIds { get; set; } = Array.Empty<int>();
	}
	public static class PresetLibrary
	{
		private static readonly JsonSerializerOptions Options = new JsonSerializerOptions
		{
			WriteIndented = true
		};

		public static PresetLibraryDto FromJson(string? json)
		{
			if (string.IsNullOrWhiteSpace(json))
			{
				return new PresetLibraryDto();
			}
			try
			{
				PresetLibraryDto? obj = JsonSerializer.Deserialize<PresetLibraryDto>(json, Options) ?? new PresetLibraryDto();
				PresetLibraryDto presetLibraryDto = obj;
				if (presetLibraryDto.Schedules == null)
				{
					List<SchedulePresetDto> list = (presetLibraryDto.Schedules = new List<SchedulePresetDto>());
				}
				presetLibraryDto = obj;
				if (presetLibraryDto.Tasks == null)
				{
					List<TasksPresetDto> list3 = (presetLibraryDto.Tasks = new List<TasksPresetDto>());
				}
				presetLibraryDto = obj;
				if (presetLibraryDto.EquipmentColors == null)
				{
					List<EquipColorPresetDto> list5 = (presetLibraryDto.EquipmentColors = new List<EquipColorPresetDto>());
				}
				return obj;
			}
			catch (JsonException)
			{
				return new PresetLibraryDto();
			}
		}

		public static string ToJson(PresetLibraryDto library)
		{
			return JsonSerializer.Serialize(library, Options);
		}

		public static PresetLibraryDto MergeCaptured(PresetLibraryDto existing, PresetLibraryDto captured)
		{
			PresetLibraryDto presetLibraryDto = new PresetLibraryDto();
			presetLibraryDto.SchemaVersion = existing.SchemaVersion;
			presetLibraryDto.Schedules.AddRange(existing.Schedules);
			AddNew(presetLibraryDto.Schedules, captured.Schedules, (SchedulePresetDto s) => s.Name);
			presetLibraryDto.Tasks.AddRange(existing.Tasks);
			AddNew(presetLibraryDto.Tasks, captured.Tasks, (TasksPresetDto t) => t.Name);
			presetLibraryDto.EquipmentColors.AddRange(existing.EquipmentColors);
			AddNew(presetLibraryDto.EquipmentColors, captured.EquipmentColors, (EquipColorPresetDto c) => c.Name);
			return presetLibraryDto;
		}

		public static PresetLibraryDto MissingFrom(PresetLibraryDto library, PresetLibraryDto inSave)
		{
			PresetLibraryDto obj = new PresetLibraryDto
			{
				SchemaVersion = library.SchemaVersion
			};
			AddNew(obj.Schedules, library.Schedules.Where((SchedulePresetDto l) => !inSave.Schedules.Any((SchedulePresetDto s) => PresetNames.SameAs(s.Name, l.Name))), (SchedulePresetDto s) => s.Name);
			AddNew(obj.Tasks, library.Tasks.Where((TasksPresetDto l) => !inSave.Tasks.Any((TasksPresetDto s) => PresetNames.SameAs(s.Name, l.Name))), (TasksPresetDto t) => t.Name);
			AddNew(obj.EquipmentColors, library.EquipmentColors.Where((EquipColorPresetDto l) => !inSave.EquipmentColors.Any((EquipColorPresetDto s) => PresetNames.SameAs(s.Name, l.Name))), (EquipColorPresetDto c) => c.Name);
			return obj;
		}

		private static void AddNew<T>(List<T> target, IEnumerable<T> candidates, Func<T, string> name)
		{
			foreach (T candidate in candidates)
			{
				if (!target.Any((T t) => PresetNames.SameAs(name(t), name(candidate))))
				{
					target.Add(candidate);
				}
			}
		}
	}
	public static class PresetNames
	{
		public const int MaxLength = 16;

		public static string Normalize(string? name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return "";
			}
			string text = name.Trim();
			if (text.Length > 16)
			{
				return text.Substring(0, 16);
			}
			return text;
		}

		public static bool SameAs(string? a, string? b)
		{
			return string.Equals(Normalize(a), Normalize(b), StringComparison.OrdinalIgnoreCase);
		}
	}
	public static class PresetValidation
	{
		public static PresetLibraryDto DropUnresolvable(PresetLibraryDto library, ISet<int> knownItemIds, ISet<int> knownDyeIds, Action<string>? onDropped = null)
		{
			PresetLibraryDto presetLibraryDto = new PresetLibraryDto
			{
				SchemaVersion = library.SchemaVersion
			};
			List<SchedulePresetDto> schedules = presetLibraryDto.Schedules;
			IEnumerable<SchedulePresetDto> schedules2 = library.Schedules;
			schedules.AddRange(schedules2 ?? Enumerable.Empty<SchedulePresetDto>());
			IEnumerable<TasksPresetDto> tasks = library.Tasks;
			foreach (TasksPresetDto task in tasks ?? Enumerable.Empty<TasksPresetDto>())
			{
				if (!knownItemIds.Contains(task.TemplateId))
				{
					onDropped?.Invoke($"tasks preset '{task.Name}': unknown template id {task.TemplateId}");
					continue;
				}
				TasksPresetDto tasksPresetDto = new TasksPresetDto
				{
					Name = task.Name,
					TemplateId = task.TemplateId
				};
				tasksPresetDto.Rows.AddRange(KeepKnown(task.Rows, (TaskRowDto row) => row.ItemId, knownItemIds, (TaskRowDto row) => $"tasks preset '{task.Name}': unknown item id {row.ItemId}", onDropped));
				presetLibraryDto.Tasks.Add(tasksPresetDto);
			}
			IEnumerable<EquipColorPresetDto> equipmentColors = library.EquipmentColors;
			foreach (EquipColorPresetDto color in equipmentColors ?? Enumerable.Empty<EquipColorPresetDto>())
			{
				List<int> list = KeepKnown(color.DyeIds, (int dye) => dye, knownDyeIds, (int dye) => $"color preset '{color.Name}': unknown dye id {dye}", onDropped);
				presetLibraryDto.EquipmentColors.Add(new EquipColorPresetDto
				{
					Name = color.Name,
					DyeIds = list.ToArray()
				});
			}
			return presetLibraryDto;
		}

		private static List<T> KeepKnown<T>(IEnumerable<T>? items, Func<T, int> idOf, ISet<int> knownIds, Func<T, string> dropMessage, Action<string>? onDropped)
		{
			List<T> list = new List<T>();
			foreach (T item in items ?? Enumerable.Empty<T>())
			{
				if (knownIds.Contains(idOf(item)))
				{
					list.Add(item);
				}
				else
				{
					onDropped?.Invoke(dropMessage(item));
				}
			}
			return list;
		}
	}
}