using Enigmos.Modules.ControllingModules;
using Enigmos.Modules.Other;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using TabulaSmaragdina;
using TabulaSmaragdina.Constants;

namespace Enigmos.Modules.TerminalModules;

public partial class MemoryModule : TerminalModule, IPolymorphismModule, IComputationalCompositeModule
{
    private DataInPort? Input1 { get; set; }
    private DataInPort? Input2 { get; set; }
    private DataInPort? Input3 { get; set; }
    private IDataPackage? Memory { get; set; }
    private IDataPortGroup? MemoryPortGroup { get; set; }
    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
    private OutputSubModule? Output1 { get; set; }
    private OutputSubModule? Output2 { get; set; }
    private OutputSubModule? Output3 { get; set; }
    private OutputSubModule? Output4 { get; set; }
    public override IEnumerable<BasePort> Ports => new BasePort[] { Input1!, Input2!, Input3! };
    public IBaseModule[] SubModules() => new IBaseModule[] { Output1!, Output2!, Output3!, Output4! };


    protected OutputSubModule GetOutputModule(string path)
    {
        OutputSubModule res = GetNode<OutputSubModule>(path);
        res.Init();
        res.ParentModule = this;
        res.Board = Board;
        return res;
    }
    public override void Init()
    {
        base.Init();
        Memory = GlobalProvider.DataStructureProvider!.NewDataPackage();
        Input1 = GetPort<DataInPort>("Input1");
        Input2 = GetPort<DataInPort>("Input2");
        Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
        Input3 = GetPort<DataInPort>("Input3");
        Input3.SetDataType(EnigmosConstant.DataPortTypes.Bit);
        Output1 = GetOutputModule("Output1");
        Output2 = GetOutputModule("Output2");
        Output3 = GetOutputModule("Output3");
        Output4 = GetOutputModule("Output4");
        MemoryPortGroup =GlobalProvider.DataStructureProvider!.NewDataPortGroup(
            this,
            new IDataPort[] { Input1, Output1.DataOut, Output2.DataOut, Output3.DataOut, Output4.DataOut },
            "Memory Data Type:",
            EnigmosConstant.DataPortTypes.Real,
            EnigmosConstant.DataPortTypes.AnyType
        );
        ConfigurablePortGroups = new HashSet<IDataPortGroup>() { MemoryPortGroup };
        PostInit();
    }

    public void Inference()
    {
    }

    public void Compute(IRootModule root)
    {
        Output1!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup!.SelectedType);
        Output2!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
        Output3!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
        Output4!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType);
    }

    protected override void Consume(RootModule root)
    {
        bool setValue = Input2!.GetData(root).Bit;
        bool resetValue = Input3!.GetData(root).Bit;
        if (setValue)
            Memory!.Assign(Input1!.GetData(root), MemoryPortGroup!.SelectedType);
        else if(resetValue)
            Memory!.Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, MemoryPortGroup!.SelectedType); 
        Finished = true;
    }

    public override void UpdateCables()
    {
        base.UpdateCables();
        foreach (BaseModule subModule in SubModules())
            subModule.UpdateCables();
        
    }
}