Enigmos/Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs

using Enigmos.Boards;
using Enigmos.Modules.InterlayerModules;
using Enigmos.Modules.SubModules;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures.ConfigurableParameters;
using Nocturnis.DataStructures.Data;
using Nocturnis.DataStructures.DataPortGroups;
using Nocturnis.DataStructures.DataTypes;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;

namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;

public abstract partial class OptimizationModule : ProgrammableModule,
	IPolymorphismModule,
	IParameterizedModule,
	IInternalComputationalModule,
	IEnumerableProcessingModule
{
	public bool ComputationFinished { get; set; }
	public bool ComputationStarted { get; set; }
	private double? CachedOptimizeValue { get; set; }
	public IDataInPort? ArrayInput { get; set; }
	public DataVariable[] CachedInputArray { get; set; } = Array.Empty<DataVariable>();
	public int ProcessingIndex { get; set; }
	private IBoolParameter? UsingMax { get; set; }
	public DataVariable CachedResult { get; set; } = new ();
	public IDataInPort? InternalIterOut { get; set; }
	public IDataOutPort? InternalArrayIn { get; set; }
	
	private IDataPortGroup[] InterlayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
	private IDataPortGroup? OptimizationGroup { get; set; }
	
	private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
	private OptimizationSelectorModule? Selector { get; set; }
	private OutputSubModule? Output { get; set; }


	public new OptimizationModuleBoard UnderlyingBoard
	{
		get => (base.UnderlyingBoard as OptimizationModuleBoard)!;
		set => base.UnderlyingBoard = value;
	}

	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();

	public override IEnumerable<IBasePort> ExplicitPorts => 
		new IBasePort[] { ArrayInput!,  Output!.Out! }
			.Union<IBasePort>(ExplicitInputs.Select(c => c.DataIn)!);
	
	public override IEnumerable<IBasePort> ImplicitPorts =>
		new IBasePort[] { UnderlyingBoard.InputProvider!.Output!, UnderlyingBoard.Selector!.Selector! }
			.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut))!;

	public override void Init()
	{
		base.Init();
		UnderlyingBoard = GlobalProvider
			.AssetMapper<OptimizationModuleBoard>.Scene
			.Instantiate<OptimizationModuleBoard>();
		UnderlyingBoard.Init();
		InterlayerGroups = new IDataPortGroup[3];
		ExplicitInputs = new InterlayerDataInModule[3];
		InternalIterOut = this.GetPort<IDataInPort>("InternalIterOut");
		Output = GetModule<OutputSubModule>("Output");
		Output.Init();
		for (int i = 0; i < 3; i++)
		{
			ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
			ExplicitInputs[i].DualModule = UnderlyingBoard.ImplicitDataOuts[i];
			UnderlyingBoard.ImplicitDataOuts[i].DualModule = ExplicitInputs[i];
		}

		ComputationFinished = true;
		CachedInputArray = Array.Empty<DataVariable>();
		ProcessingIndex = 0;
		CachedResult = new DataVariable();
		CachedOptimizeValue = null;
		
		ArrayInput = this.GetPort<DataInPort>("ArrayInput");
		
		for (int i = 0; i < 3; i++)
		{
			InterlayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
				this, 
				new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.ImplicitDataOuts[i].DataOut! }, 
				$"Exterior In -> Interior Out{i}", 
				DataTypeConstant.BaseDataTypes.Real, 
				DataTypeConstant.DataTypeOptions.AnyType
			);
			ExplicitInputs[i].Board = Board;
		}

		OptimizationGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
			this, 
			new IDataPort[] { ArrayInput }, 
			"Array Input Type",
			DataTypeConstant.AutoDataTypes.AutoArray, 
			DataTypeConstant.DataTypeOptions.AnyArray
		);
		UsingMax = GlobalProvider.DataStructureProvider.NewBoolParameter(
			"Method",
			"Max",
			"Min",
			true
		);
		Output.Out!.SetDataType(DataTypeConstant.BaseDataTypes.Real);
		Selector!.Selector!.SetDataType(DataTypeConstant.BaseDataTypes.Real);
		ConfigurableParameters = new HashSet<IConfigurableParameter> { UsingMax };
		ConfigurablePortGroups = 
			InterlayerGroups.Union(new[] { OptimizationGroup }).ToHashSet();
		PostInit();
		
	}


	public void Inference()
	{
		DataType elementType = GlobalProvider.DataTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
		Output!.Out!.SetDataType(elementType);
		UnderlyingBoard.InputProvider!.Output!.SetDataType(elementType);
	}

	private void SoftReset() => UnderlyingBoard.Reset();

	public void Compute()
	{
		if (ComputationFinished)
		{
			CachedOptimizeValue = null;
			CachedInputArray = InternalArrayIn!.OutData.Get!.Array;
			CachedResult = new();
			ProcessingIndex = 0;
		}

		while (ProcessingIndex < CachedInputArray.Length)
		{
			SoftReset();
			UnderlyingBoard.InputProvider!.Output!.OutData.UpdateCalculation(
				cache =>
					(CachedInputArray[ProcessingIndex].Data, CachedInputArray[ProcessingIndex].Type)!
			);
			UnderlyingBoard.InputProvider.Output.OutData.Expire();
			double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Real;
			DataVariable currentOut = InternalIterOut!.GetData.Get!;
			if (UsingMax!.ParameterValue)
			{
				if (CachedOptimizeValue == null || (CachedOptimizeValue < currentValue))
				{
					CachedOptimizeValue = currentValue;
					CachedResult.Assign(currentOut.Data!, currentOut.Type!);
				}
			}
			else
			{
				if (CachedOptimizeValue == null || CachedOptimizeValue > currentValue)
				{
					CachedOptimizeValue = currentValue;
					CachedResult.Assign(currentOut.Data!, currentOut.Type!);
				}
			}
			ProcessingIndex++;
			
		}
		Output!.Define();
		ComputationFinished = true;
	}
}