Fact.cs

using JsonSubTypes;
using Newtonsoft.Json;
using REST_JSON_API;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using UnityEngine;
using UnityEngine.Networking;

public static class ParsingDictionary
{
    //TODO? get rid of this, use reflection? instead, if possible
    //TODO: docu

    public static Dictionary<string, Func<List<Fact>, MMTFact, IEnumerator>> parseFactDictionary = new() {
        { MMTConstants.TypeType,
            GeneralFact.parseFact },
        { MMTConstants.Point,
            PointFact.parseFact },
        { MMTConstants.Metric,
            LineFact.parseFact },
        { MMTConstants.Angle,
            AngleFact.parseFact },
        { MMTConstants.Eq,
            RightAngleFact.parseFact },
        { MMTConstants.RightAngle,
            RightAngleFact.parseFact },
        { MMTConstants.LineType,
            RayFact.parseFact },
        { MMTConstants.LineOf,
            RayFact.parseFact },
        { MMTConstants.OnLine,
            OnLineFact.parseFact },
        { MMTConstants.ParallelLine,
            ParallelLineFact.parseFact },
        { MMTConstants.CircleType3d,
            CircleFact.parseFact },
        { MMTConstants.OnCircle,
            OnCircleFact.parseFact },
        { MMTConstants.AnglePlaneLine,
            AngleCircleLineFact.parseFact },
        { MMTConstants.RadiusCircleMetric,
            RadiusFact.parseFact },
        { MMTConstants.AreaCircle,
            AreaCircleFact.parseFact },
        { MMTConstants.OrthoCircleLine,
            OrthogonalCircleLineFact.parseFact },
        { MMTConstants.VolumeCone,
            ConeVolumeFact.parseFact },
        { MMTConstants.TruncatedVolumeCone,
            TruncatedConeVolumeFact.parseFact },
        { MMTConstants.CylinderVolume,
            CylinderVolumeFact.parseFact },
        { MMTConstants.TestType,
            TestFact.parseFact },
        { MMTConstants.EqualityCircles,
            EqualCirclesFact.parseFact },
        { MMTConstants.UnEqualityCircles,
            UnEqualCirclesFact.parseFact },
        { MMTConstants.CreateWall,
            QuadFact.parseFact },
        { MMTConstants.CreateTriangle,
            TriangleFact.parseFact },
        { MMTConstants.ListType,
            DynamicListFact.parseFact },
        { MMTConstants.Product,
            DynamicTupleFact.parseFact },
        { MMTConstants.FunctionFact,
            FunctionFact.parseFact },
    };

    // TODO: get rid of this
    public static Dictionary<string, string> parseTermsToId = new();
}


/// <summary>
/// %Fact representation of Unity; mostly mirrors Facts of MMT.
/// </summary>
[JsonConverter(typeof(JsonSubtypes), "s_type")]
[JsonSubtypes.KnownSubType(typeof(PointFact), nameof(PointFact))]
[JsonSubtypes.KnownSubType(typeof(LineFact), nameof(LineFact))]
[JsonSubtypes.KnownSubType(typeof(RayFact), nameof(RayFact))]
[JsonSubtypes.KnownSubType(typeof(OnLineFact), nameof(OnLineFact))]
[JsonSubtypes.KnownSubType(typeof(AngleFact), nameof(AngleFact))]
[JsonSubtypes.KnownSubType(typeof(CircleFact), nameof(CircleFact))]
[JsonSubtypes.KnownSubType(typeof(ParallelLineFact), nameof(ParallelLineFact))]
[JsonSubtypes.KnownSubType(typeof(OnCircleFact), nameof(OnCircleFact))]
[JsonSubtypes.KnownSubType(typeof(AngleCircleLineFact), nameof(AngleCircleLineFact))]
[JsonSubtypes.KnownSubType(typeof(OrthogonalCircleLineFact), nameof(OrthogonalCircleLineFact))]
[JsonSubtypes.KnownSubType(typeof(AreaCircleFact), nameof(AreaCircleFact))]
[JsonSubtypes.KnownSubType(typeof(RadiusFact), nameof(RadiusFact))]
[JsonSubtypes.KnownSubType(typeof(ConeVolumeFact), nameof(ConeVolumeFact))]
[JsonSubtypes.KnownSubType(typeof(TruncatedConeVolumeFact), nameof(TruncatedConeVolumeFact))]
[JsonSubtypes.KnownSubType(typeof(RightAngleFact), nameof(RightAngleFact))]
[JsonSubtypes.KnownSubType(typeof(CylinderVolumeFact), nameof(CylinderVolumeFact))]
[JsonSubtypes.KnownSubType(typeof(TestFact), nameof(TestFact))]
[JsonSubtypes.KnownSubType(typeof(EqualCirclesFact), nameof(EqualCirclesFact))]
[JsonSubtypes.KnownSubType(typeof(UnEqualCirclesFact), nameof(UnEqualCirclesFact))]
[JsonSubtypes.KnownSubType(typeof(FunctionFact), nameof(FunctionFact))]
[JsonSubtypes.KnownSubType(typeof(FunctionCallFact), nameof(FunctionCallFact))]
[JsonSubtypes.KnownSubType(typeof(ListFact), nameof(ListFact))]
[JsonSubtypes.KnownSubType(typeof(TupleFact), nameof(TupleFact))]
[JsonSubtypes.KnownSubType(typeof(DynamicListFact), nameof(DynamicListFact))]
[JsonSubtypes.KnownSubType(typeof(DynamicTupleFact), nameof(DynamicTupleFact))]
[JsonSubtypes.KnownSubType(typeof(QuadFact), nameof(QuadFact))]
[JsonSubtypes.KnownSubType(typeof(TriangleFact), nameof(TriangleFact))]
[JsonSubtypes.KnownSubType(typeof(RealLitFact), nameof(RealLitFact))]
public abstract class Fact
{
    [JsonIgnore]
    public Expression CompileBase
    {
        get
        {
            if (_CompileBase == null)
                CompileValue(HasServerTwin ? Defines() : ServerDefinition);
            return _CompileBase;
        }

        protected set => _CompileBase = value;
    }
    private Expression _CompileBase;

    [JsonIgnore]
    public object CompiledValue
    {
        get => _CompiledValue ??= GetCompiledValue();
        protected set => _CompiledValue = value;
    }
    private object _CompiledValue;
    protected virtual object GetCompiledValue()  // put to abstract, once we know what to do with every Fact
        => CompileValue(HasServerTwin ? Defines() : ServerDefinition);

    protected object CompileValue(SOMDoc compile_me)
    {
        Func<object[], object[]> builder =
            compile_me.PartialInvokeCastingLambdaExpression(out _CompileBase, out Type[] Signature);

        if (Signature.Length != 1)
            throw new InvalidCastException($"{nameof(ServerDefinition)} does not compile to constant!");

        return _CompiledValue = Signature[0] == typeof(object[])
            ? builder(new object[0])
            : builder(new object[0])[0];
    }

    /// <summary>
    /// Reference to <c>GameObject</c> that represents this Fact in the GameWorld.
    /// </summary>
    /// <seealso cref="FactObject3D"/>
    [JsonIgnore]
    public FactWrapper WorldRepresentation;

    /// <summary>
    /// Collection of <c>Type</c>s of *all* available <see cref="Fact"/>s to choose from.
    /// </summary>
    [JsonIgnore]
    public static readonly Type[] Types = TypeExtensions<Fact>.UAssemblyInheritenceTypes;

    /// <value>
    /// [ClassName] for JSON de-/serialization.
    /// Automatically set in <see cref="Fact()"/> for <b>NON-Generiy-Types</b>!
    /// Also add JsonSubtypes.KnownSubType decorator for deserialization to Fact!
    /// </value>
    [JsonProperty]
    protected string s_type;

    /// <returns><see langword="true"/> if Fact depends on other \ref Fact "Facts"; equivalent to <see cref="getDependentFactIds"/> returns non empty array</returns>
    [JsonIgnore]
    public virtual bool HasDependentFacts => DependentFactIds.Length > 0;

    /// <returns> array of Fact <see cref="Id"> Ids </see> on which this Fact depends.</returns>
    /// <example><see cref="AngleFact"/> needs 3 <see cref="PointFact"/>s to be defined.</example>
    [JsonIgnore]
    public string[] DependentFactIds => _DependentFactIds ??= GetDependentFactIds();
    private string[] _DependentFactIds;

    /// <returns> array of Fact <see cref="Id"> Ids </see> on which this Fact depends.</returns>
    /// <example><see cref="AngleFact"/> needs 3 <see cref="PointFact"/>s to be defined.</example>
    protected abstract string[] GetDependentFactIds();

    /// <value>Unique Id. e.g.: MMT URI</value>
    [JsonIgnore]
    public string Id
    {
        get
        {
            //while (FetchURICoroutine.MoveNext()) ; //active wait for server
            return ServerDefinition?.ToString() ?? ScalaFact.ToString();
        }
    }
    //private IEnumerator FetchURICoroutine = IEnumeratorExtensions.yield_break;

    /// <summary>AST which the Server understands. e.g.: OMS(MMT URI)</summary>
    [JsonIgnore]
    public SOMDoc ServerDefinition
    {
        get => _ServerDefinition ??= Defines();
        protected set => _ServerDefinition = value;
    }
    private SOMDoc _ServerDefinition = null;

    [JsonIgnore]
    public MMTFact ScalaFact
    {
        get => _ScalaFact ??= MakeMMTDeclaration();
        protected set => _ScalaFact = value;
    }
    private MMTFact _ScalaFact = null;

    //public MMTFact MMTFact => _MMTFact ??= MakeMMTDeclaration();
    //private MMTFact _MMTFact = null;

    [JsonIgnore]
    public bool HasServerTwin => ServerDefinition is OMS;

    /// <value>
    /// <c>get</c> initiates and subsequently updates a human readable name.
    /// <c>set</c> calls <see cref="rename(string, FactRecorder)"/>
    /// </value>
    public string GetLabel(FactRecorder name_space)
    {  // in case of renamed dependables
        return _LastLabel = (
               name_space == null // JsonSerialization toggle (_Facts.GetNumberOfFacts() == 0 && this is not PointFact) // JsonSerialization toggle && allow first (Point)Fact to be created
            || (hasCustomLabel && _CustomLabel != null)
            ? _CustomLabel
            : generateLabel(name_space));
    }
    protected internal string _LastLabel = "NaN";

    public bool SetLabel(string value, FactRecorder name_space)
    {
        if (name_space == null) // JsonSerialization toggle)
        {
            _CustomLabel = value;
            LabelId = -LabelId;
            return true;
        }
        else
            return rename(value, name_space);
    }


    /// <value>
    /// Is true if Fact has a custom <see cref="GetLabel"/> which is not <c>null</c> or <c>""</c>.
    /// </value>
    public bool hasCustomLabel => LabelId < 0;

    /// <summary>
    /// Stores custom <see cref="GetLabel"/> if set.
    /// </summary>
    [JsonProperty]
    protected string _CustomLabel = null;

    /// <summary>
    /// Counter to organize auto generated <see cref="GetLabel"/>.
    /// Set to negative, if custom \ref Label is assigned.
    /// </summary>
    // property for JSON to set AFTER Label => declare AFTER Label
    public int LabelId { get; set; }

    [JsonIgnore]
    bool ForceRecalculateTransform = true;

    [JsonIgnore]
    public Vector3 Position
    {
        get
        {
            if (ForceRecalculateTransform)
                RecalculateTransform();
            return _Position;
        }
        protected set
        {
            ForceRecalculateTransform = false;
            _Position = value;
        }
    }
    private Vector3 _Position = Vector3.zero;

    [JsonIgnore]
    public Quaternion Rotation
    {
        get
        {
            if (ForceRecalculateTransform)
                RecalculateTransform();
            return _Rotation;
        }
        protected set
        {
            ForceRecalculateTransform = false;
            _Rotation = value;
        }
    }
    private Quaternion _Rotation = Quaternion.identity;

    [JsonIgnore]
    public Vector3 LocalScale
    {
        get
        {
            if (ForceRecalculateTransform)
                RecalculateTransform();
            return _LocalScale;
        }
        protected set
        {
            ForceRecalculateTransform = false;
            _LocalScale = value;
        }
    }
    private Vector3 _LocalScale = Vector3.one;

    /// <summary>
    /// Only being used by [JsonReader](https://www.newtonsoft.com/json/help/html/T_Newtonsoft_Json_JsonReader.htm) to initiate empty \ref Fact "Facts".
    /// <seealso cref="SOMDocManager"/>
    /// </summary>
    protected Fact()
    {
        LabelId = 0;
        s_type = this.GetType().Name;
    }

    /// <summary>
    /// Copies <paramref name="fact"/> by initiating new MMT %Fact.
    /// </summary>
    /// <param name="fact">Fact to be copied</param>
    /// <param name="old_to_new"><c>Dictionary</c> mapping <paramref name="fact"/>.<see cref="getDependentFactIds"/> to corresponding <see cref="Fact.Id"/> in <paramref name="organizer"/> </param>
    /// <param name="organizer">for Labeling<see cref="GetLabel(FactRecorder)"/></param>
    public Fact ReInitializeMe(Dictionary<string, string> old_to_new, FactRecorder organizer)
    {
        Fact ret = _ReInitializeMe(old_to_new);

        ret.LabelId = this.LabelId;
        if (ret.hasCustomLabel)
            ret._CustomLabel = this.GetLabel(organizer);

        return ret;
    }
    protected abstract Fact _ReInitializeMe(Dictionary<string, string> old_to_new);

    /// <summary>
    /// Assignes a custom <see cref="GetLabel"/>, if <paramref name="newLabel"/> is not yet taken;
    /// or clears custom <see cref="GetLabel"/>.
    /// </summary>
    /// <param name="newLabel">To be new <see cref="GetLabel"/>. To reset to auto-generation set to <c>null</c> or <c>""</c>.</param>
    /// <returns></returns>

    //TODO: notify about updated dependable Labelnames for UI
    //TODO: check for colissions with not yet generated names
    public bool rename(string newLabel, FactRecorder name_space)
    // returns true if succeded
    {
        if (string.IsNullOrEmpty(newLabel) && name_space.GetNumberOfFacts() != 0)
        // switch back to autogenerated
        {
            generateLabel(name_space);
            _CustomLabel = null;
            return true;
        }
        else
        // set CustomLabel if available
        {
            if (name_space.ContainsLabel(newLabel))
                return false;

            freeAutoLabel(name_space);
            _CustomLabel = newLabel;

            return true;
        }
    }

    protected abstract void RecalculateTransform();

    public abstract MMTFact MakeMMTDeclaration();
    public abstract SOMDoc Defines();

    /// <summary>
    /// Frees ressources e.g. <see cref="GetLabel"/> and will eventually delete %Fact Server-Side in far-near future when feature is supported.
    /// </summary>
    ~Fact()
    {
        //TODO: MMT: delete over there

        //freeAutoLabel(_Facts); //should be done already

        if (CommunicationEvents.VerboseURI)
            Debug.Log("Server removed Fact:\n" + this.Id);
    }

    /// <summary>
    /// Compares \ref Fact "this" against <paramref name="f2"/>.
    /// </summary>
    /// <param name="f2">Fact to compare to</param>
    /// <returns><c>true</c> if <paramref name="f2"/> is semantical very similar to \ref Fact "this"</returns>
    public abstract bool Equivalent(Fact f2);

    /// <summary>
    /// Compares <paramref name="f1"/> against <paramref name="f2"/>.
    /// </summary>
    /// <param name="f1">Fact to compare to</param>
    /// <param name="f2">Fact to compare to</param>
    /// <returns><c>true</c> if <paramref name="f2"/> is semantical very similar to <paramref name="f1"/></returns>
    public abstract bool Equivalent(Fact f1, Fact f2);

    /// <summary>
    /// canonical
    /// </summary>
    /// <returns>unique-ish Hash</returns>
    public new virtual int GetHashCode()
        => DependentFactIds
            .Select(id => id.GetHashCode())
            .Aggregate((hash1, hash2) => hash1 ^ hash2);

    /// <summary>
    /// auto-generates <see cref="GetLabel"/> using generation variable(s) e.g. <see cref="LabelId"/>;
    /// if custom <see cref="GetLabel"/> is set, tries to restore original generated <see cref="GetLabel"/> **without** resetting <see cref="_CustomLabel"/>. If original <see cref="GetLabel"/> is already taken, a new one will be generated.
    /// </summary>
    /// <returns>auto-generated <see cref="GetLabel"/></returns>
    protected virtual string generateLabel(FactRecorder name_space)
    {
        if (LabelId < 0)
            // reload Label if possible
            LabelId = name_space.UnusedLabelIds.Remove(-LabelId) ? -LabelId : 0;

        if (LabelId == 0)
            if (name_space.UnusedLabelIds.Count == 0)
                LabelId = ++name_space.MaxLabelId;
            else
            {
                LabelId = name_space.UnusedLabelIds.Min;
                name_space.UnusedLabelIds.Remove(LabelId);
            }

        return ((char)(64 + LabelId)).ToString();
    }

    /// <summary>
    /// Parses <see cref="MMTFact"/> to actual Fact
    /// </summary>
    /// <param name="fact">instance to be parsed</param>
    /// <returns>parsed Fact</returns>
    public static IEnumerator parseFact(List<Fact> ret, MMTFact fact)
        => null;

    public virtual SOMDoc GetMMTType()
        => new OMS(MMTConstants.TYPE_TO_OMS[GetType()]);

    /// <summary>
    /// Tells a <see cref="FactRecorder"/> that \ref Fact "this" no longer uses auto-generated <see cref="GetLabel"/>, but remembers current generation variable(s).
    /// </summary>
    public void freeAutoLabel(FactRecorder name_space)
    {
        if (LabelId > 0)
        {
            name_space.UnusedLabelIds.Add(LabelId);
            // store Label for name-persistance
            LabelId = -LabelId;
        }
    }

    private static readonly List<Type> ServerBlacklist = new()
    {
        typeof(FunctionFact),
        typeof(FunctionCallFact),
        //typeof(DynamicListFact),
    };

    private bool SendedToMMT = false;
    public void SendToMMT()
    {
        if (ServerBlacklist.Contains(GetType()))
            return;

        if (!SendedToMMT && !HasServerTwin)
        {
            ServerDefinition = SendToMMT(MakeMMTDeclaration());
            SendedToMMT = true;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    /// <remarks>Asynchron version has proofen inefficent, since <see cref="Fact.Id"/> is usually called in close proximity.</remarks>
    // Asynchron version in comments
    public static SOMDoc SendToMMT(MMTFact mmtDecl)
    {
        //GlobalBehaviour.Instance.StartCoroutine(
        //    FetchURICoroutine = 
        //_URI =
        string uri =
            _SendAdd(
                CommunicationEvents.ServerAdress + "/fact/add",
                JsonConvert.SerializeObject(mmtDecl)
        //,(string uri) => _SendURICallback(mmtDecl, uri)
        );//);

        //return;

        //void _SendURICallback(MMTDeclaration mmtDecl, string uri)
        //{
        //    _URI = uri;

        if (mmtDecl is MMTGeneralFact mMTSymbol && mMTSymbol.defines != null)
            ParsingDictionary.parseTermsToId[mMTSymbol.defines.ToString()] = uri;// _URI;
                                                                                 //}
        if (uri == null)
        {
            Debug.LogWarning("Server rejected MMTFact; Fallback engaged.");
            return mmtDecl.GetDefines();
        }
        else
            return new OMS(uri);

        /*IEnumerator*/
        static string _SendAdd(string path, string body)//, Action<string> uriCallback)
        {
            if (!CommunicationEvents.ServerRunning)
            {
                Debug.LogWarning("Server not running");
                //uriCallback(null);
                return null; // yield break;
            }

            if (CommunicationEvents.VerboseURI)
                Debug.Log("Sending to Server:\n" + body);

            //Put constructor parses stringbody to byteArray internally  (goofy workaround)
            using UnityWebRequest www = UnityWebRequest.Put(path, body);
            www.method = UnityWebRequest.kHttpVerbPOST;
            www.SetRequestHeader("Content-Type", "application/json");
            www.timeout = 1;

            //yield return 
            UnityWebRequestAsyncOperation web =
                www.SendWebRequest();

            while (!web.isDone // not enough as querry
                 && www.result == UnityWebRequest.Result.InProgress) ;

            if (www.result == UnityWebRequest.Result.ConnectionError
             || www.result == UnityWebRequest.Result.ProtocolError)
            {
                Debug.LogWarning(www.error);
                //uriCallback(null);
                return null; // yield break;
            }

            while (!www.downloadHandler.isDone)
                //yield return null
                ;

            FactReference res = JsonUtility.FromJson<FactReference>(www.downloadHandler.text);

            if (CommunicationEvents.VerboseURI)
                Debug.Log("Server added Fact:\n" + res.uri);

            //uriCallback(res.uri);
            return res.uri; // yield break;
        }
    }

    /// <summary> Used by <see cref="MakeFact(List{Fact}, object, SOMDoc, bool, SOMDoc)"/> to create unique pseudo-URIs / <see cref="Id"/>s. </summary>
    private static uint bypasscc = 0;
    /// <summary>
    /// Tries to parse <paramref name="payload"/> into <see cref="Fact"/>(s)
    /// </summary>
    /// <param name="ret">to add results to</param>
    /// <param name="payload">to be parsed</param>
    /// <param name="ServerDefinition">what the Server could use. Only relevant for certain types of <paramref name="payload"/>.</param>
    /// <param name="BypassServer">iff <c>true</c> avoids Server-side initialization</param>
    /// <param name="BypassURI">iff <c><paramref name="BypassServer"/>==true</c> used as Server reference; iff set <c>null</c> a unique pseudo reference will be generated</param>
    /// <exception cref="NotImplementedException">iff <paramref name="payload"/> is of unhandled type</exception>
    public static void MakeFact(List<Fact> ret, object payload, SOMDoc ServerDefinition, bool BypassServer, SOMDoc BypassURI = null)
    {
        Type type = payload.GetType();

        if (BypassServer
         && BypassURI == null)
            BypassURI = new OMLIT<uint>(++bypasscc);

        if (payload is Fact fact)
            ret.Add(fact);
        else
        if (payload is float f)
            ret.Add(BypassServer
                ? new RealLitFact(f, BypassURI)
                : new RealLitFact(f));
        else
        if (payload is Vector3 point)
            ret.Add(BypassServer
                ? new PointFact(point, BypassURI)
                : new PointFact(point, Vector3.up));
        else
        if (FuncExtensions.IsFuncType(type, out _))
            ret.Add(BypassServer
                ? new FunctionFact(ServerDefinition, BypassURI)
                : new FunctionFact(ServerDefinition));
        else
        if (TupleExtensions.IsTupleType(type, out _))
            ret.AddRange(BypassServer
                ? DynamicTupleFact.MMTFactory(payload, ServerDefinition, SOMDoc.SOMDocType(type), BypassURI)
                : DynamicTupleFact.MMTFactory(payload, ServerDefinition, SOMDoc.SOMDocType(type)));
        else
        if (type.IsGenericType
         && type.GetGenericTypeDefinition() == typeof(List<>))
            ret.AddRange(BypassServer
                ? DynamicListFact.MMTFactory(Enumerable.ToList<dynamic>((dynamic)payload), ServerDefinition, SOMDoc.SOMDocType(type), BypassURI)
                : DynamicListFact.MMTFactory(Enumerable.ToList<dynamic>((dynamic)payload), ServerDefinition, SOMDoc.SOMDocType(type)));
        else
        if (type.IsAnonymousType()) // TODO? generic Fact
            return;
        else
            throw new NotImplementedException($"For Type {type}.");
        return;
    }

    /// <summary>
    /// Compiles/Executes <paramref name="ingredient"/> and parses result into @Fact s
    /// </summary>
    /// <param name="ingredient">MMT package to be interpreted</param>
    /// <returns>containing all @Fact s succesfully parsed, or empty when failed.</returns>
    public static List<Fact> MMTFactory(MMTFact ingredient)
    {
        List<Fact> ret = new();

        SOMDoc indirect_payload = ingredient.GetDefines();
        if (indirect_payload == null)
            return ret;

        // First try static approach
        try
        {
            ParsingDictionary.parseFactDictionary[ingredient.getType()]
                .Invoke(ret, ingredient)
                .FastForward();

            if (ret.Count != 0)
                return ret;
        }
        catch(Exception ex)
        {
            Debug.LogException(ex);
            Debug.Log($"Could not statically parse {nameof(MMTFact)} {nameof(ingredient)}. Using dynamic Fallback...");
        }

        object CompiledValue;
        try
        {
            Func<object[], object[]> builder =
                indirect_payload.PartialInvokeCastingLambdaExpression(out _, out Type[] signature);

            if (signature.Length != 1)
                return new();

            CompiledValue = builder(new object[0])[0];
        }
        catch (Exception ex)
        {
            Debug.Log($"{nameof(ingredient)} could not be built/executed:");
            Debug.LogException(ex);
            return new();
        }

        //try // simplify
        //{
        //    indirect_payload = SOMDoc.SOMDocObject(CompiledValue);
        //}
        //catch (NotSupportedException) { }

        MakeFact(ret, CompiledValue, indirect_payload, false, ingredient.@ref); //true => server does not recognize fact

        return ret;
    }
}


public interface IUnpackable
{
    public abstract IEnumerator UnpackMe(List<Fact> ret, bool BypassServer);
}

/// <summary>
/// Implements CRTP for <see cref="Fact"/>; Escalates constructors;
/// </summary>
/// <typeparam name="T">class, which inherits from FactWrappedCRTP</typeparam>
public abstract class FactWrappedCRTP<T> : Fact where T : FactWrappedCRTP<T>
{
    /// <summary>\copydoc Fact.Fact()</summary>
    protected FactWrappedCRTP() : base() { }

    /// \copydoc Fact.Equivalent(Fact)
    public override bool Equivalent(Fact f2)
        => Equivalent(this, f2);

    /// \copydoc Fact.Equivalent(Fact, Fact)
    public override bool Equivalent(Fact f1, Fact f2)
        => f1.GetType() == f2.GetType()
        && EquivalentWrapped((T)f1, (T)f2); // || f1.ServerDefinition.Equivalent(f2.ServerDefinition); <= StackOverflow

    /// <summary>CRTP step of <see cref="Equivalent(Fact)"/> and <see cref="Equivalent(Fact, Fact)"/></summary>
    protected abstract bool EquivalentWrapped(T f1, T f2);

    protected bool DependentFactsEquivalent(T f1, T f2)
        => f1.DependentFactIds
            .Zip(f2.DependentFactIds,
                (id1, id2) =>
                    id1 == id2
                    || (FactRecorder.AllFacts.ContainsKey(id1)
                     && FactRecorder.AllFacts.ContainsKey(id2)
                     && FactRecorder.AllFacts[id1].Equivalent(FactRecorder.AllFacts[id2]))
            )
            .All(b => b);
}

#pragma warning disable // Testing...

/// TEST FACT
/// use this if you need to test certain implementations of facts.

/// <summary>
/// just for testing purposes  
/// </summary>
public class TestFact : FactWrappedCRTP<TestFact>
{
    /// <summary> \copydoc Fact.Fact </summary>
    public TestFact() : base()
    {

    }

    protected override void RecalculateTransform() { }

    /// <summary>
    /// Bypasses initialization of new MMT %Fact by using existend URI, _which is not checked for existence_.
    /// </summary>
    /// <param name="Pid1">sets <see cref="Pid1"/></param>
    /// <param name="Pid2">sets <see cref="Pid2"/></param>
    /// <param name="radius">sets <see cref="radius"/></param>
    /// <param name="normal">sets <see cref="normal"/></param>
    /// <param name="backendURI">MMT URI</param>
    public TestFact(string backendURI) : base()
    {
        this.ServerDefinition = ServerDefinition;
    }

    /// <summary>
    /// parses the Circlefact response of the MMT-Server
    /// </summary>
    /// \copydoc Fact.parseFact(ScrollFact) 
    public new static IEnumerator parseFact(List<Fact> ret, MMTFact fact)
    {
        string uri = fact.@ref.uri;
        Debug.Log("TestFact Uri:" + uri);
        ret.Add(new TestFact(uri));
        yield break;
    }

    /// \copydoc Fact.generateLabel
    protected override string generateLabel(FactRecorder _Facts)
        => "test";

    /// \copydoc Fact.hasDependentFacts
    public override bool HasDependentFacts => false;

    /// \copydoc Fact.getDependentFactIds
    protected override string[] GetDependentFactIds()
        => new string[] { };

    /// \copydoc Fact.GetHashCode
    public override int GetHashCode()
        => base.GetHashCode();// this.Pid1.GetHashCode() ^ this.Pid2.GetHashCode();

    /// \copydoc Fact.Equivalent(Fact, Fact)
    protected override bool EquivalentWrapped(TestFact f1, TestFact f2)
    {
        return DependentFactsEquivalent(f1, f2);
    }

    protected override Fact _ReInitializeMe(Dictionary<string, string> old_to_new)
        => new TestFact();

    public override MMTFact MakeMMTDeclaration()
    {
        throw new NotImplementedException();
    }
    
    public override SOMDoc Defines()
    {
        throw new NotImplementedException();
    }
}

#pragma warning restore // Testing over