Fact.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
using TMPro;
using Newtonsoft.Json;
using JsonSubTypes;
using System.Linq;
using static SOMDocManager;

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

    public static Dictionary<string, Func<MMTDeclaration, Fact>> parseFactDictionary = new() {
        { MMT_OMS_URI.Point,
            PointFact.parseFact },
        { MMT_OMS_URI.Metric,
            LineFact.parseFact },
        { MMT_OMS_URI.Angle,
            AngleFact.parseFact },
        { MMT_OMS_URI.Eq,
            AngleFact.parseFact },
        { MMT_OMS_URI.RightAngle,
            RightAngleFact.parseFact },
        { MMT_OMS_URI.LineType,
            RayFact.parseFact },
        { MMT_OMS_URI.LineOf,
            RayFact.parseFact },
        { MMT_OMS_URI.OnLine,
            OnLineFact.parseFact },
        { MMT_OMS_URI.ParallelLine,
            ParallelLineFact.parseFact },
        { MMT_OMS_URI.CircleType3d,
            CircleFact.parseFact },
        { MMT_OMS_URI.OnCircle,
            OnCircleFact.parseFact },
        { MMT_OMS_URI.AnglePlaneLine,
            AngleCircleLineFact.parseFact },
        { MMT_OMS_URI.RadiusCircleMetric,
            RadiusFact.parseFact },
        { MMT_OMS_URI.AreaCircle,
            AreaCircleFact.parseFact },
        { MMT_OMS_URI.OrthoCircleLine,
            OrthogonalCircleLineFact.parseFact },
        { MMT_OMS_URI.VolumeCone,
            ConeVolumeFact.parseFact },
        { MMT_OMS_URI.TruncatedVolumeCone,
            TruncatedConeVolumeFact.parseFact },
        { MMT_OMS_URI.CylinderVolume,
            CylinderVolumeFact.parseFact },
        { MMT_OMS_URI.TestType,
            TestFact.parseFact },
        { MMT_OMS_URI.EqualityCircles,
            EqualCirclesFact.parseFact },
        { MMT_OMS_URI.UnEqualityCircles,
            UnEqualCirclesFact.parseFact }
    };

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

/// <summary>
/// class to Read AddFact Responses.
/// </summary>
// TODO: docu
public class AddFactResponse
{
    public string uri;

    public static bool sendAdd(MMTDeclaration mmtDecl, out string uri)
    {
        string body = MMTSymbolDeclaration.ToJson(mmtDecl);
        bool success = sendAdd(CommunicationEvents.ServerAdress + "/fact/add", body, out uri);

        if (mmtDecl is MMTSymbolDeclaration mMTSymbol && mMTSymbol.defines != null)
            ParsingDictionary.parseTermsToId[mMTSymbol.defines.ToString()] = uri;
        return success;
    }

    public static bool sendAdd(string path, string body, out string uri)
    {
        if (!CommunicationEvents.ServerRunning)
        {
            Debug.LogWarning("Server not running");
            uri = null;
            return false;
        }

        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;

        //TODO: implement real asynchronous communication ...
        AsyncOperation op = www.SendWebRequest();
        while (!op.isDone) ;

        if (www.result == UnityWebRequest.Result.ConnectionError
         || www.result == UnityWebRequest.Result.ProtocolError)
        {
            Debug.LogWarning(www.error);
            uri = null;
            return false;
        }
        else
        {
            string answer = www.downloadHandler.text;
            AddFactResponse res = JsonUtility.FromJson<AddFactResponse>(answer);

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

            uri = res.uri;
            return true;
        }
    }
}

/// <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(AttachedPositionFunction), nameof(AttachedPositionFunction))]
[JsonSubtypes.KnownSubType(typeof(FunctionFact), nameof(FunctionFact))]
[JsonSubtypes.KnownSubType(typeof(FunctionCallFact), nameof(FunctionCallFact))]
//[JsonSubtypes.KnownSubType(typeof(FunctionFact<T0, TResult>), "FunctionFact<T0, TResult>")] //TODO: generics? => nameof does not work (generic agnostic)
//[JsonSubtypes.KnownSubType(typeof(FunctionFactFloat<Vector3>), "FunctionFact<System.Single, UnityEngine.Vector3>")]
public abstract class Fact
{
    /// <summary>
    /// Reference to <c>GameObject</c> that represents this Fact in the GameWorld.
    /// </summary>
    /// <seealso cref="FactObject"/>
    [JsonIgnore]
    public GameObject Representation;

    /// <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 abstract bool HasDependentFacts { get; }

    /// <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>
    public string[] DependentFactIds => _DependentFactIds ??= GetGetDependentFactIds();
    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[] GetGetDependentFactIds();

    /// <value>
    /// Unique Id. e.g.: MMT URI
    /// </value>
    public string Id
    {
        get { return _URI; }
        set { _URI ??= value; } // needed for JSON
    }

    /// <summary>
    /// MMT URI