Fact.cs

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Networking;
using TMPro;
using Newtonsoft.Json;
using static JSONManager;
using static CommunicationEvents;
using JsonSubTypes;
using System.Linq.Expressions;
using UnityEngine.ProBuilder;
using System.Reflection;
using System.Linq;

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

    //public static Dictionary<string, Func<Scroll.ScrollFact, Fact>> parseFactDictionary = new Dictionary<string, Func<Scroll.ScrollFact, Fact>>() {
    public static Dictionary<string, Func<Scroll.ScrollFact, Fact>> parseFactDictionary = new() {
        {JSONManager.MMTURIs.Point, PointFact.parseFact},
        {JSONManager.MMTURIs.Metric, LineFact.parseFact},
        {JSONManager.MMTURIs.Angle, AngleFact.parseFact},
        {JSONManager.MMTURIs.LineType, RayFact.parseFact},
        {JSONManager.MMTURIs.LineOf, RayFact.parseFact},
        {JSONManager.MMTURIs.OnLine, OnLineFact.parseFact},
        //90Degree-Angle
        {JSONManager.MMTURIs.Eq, AngleFact.parseFact},
        //Parallel-LineFact
        {JSONManager.MMTURIs.ParallelLine, ParallelLineFact.parseFact},
        //CircleFact
        {JSONManager.MMTURIs.CircleType3d, CircleFact.parseFact},
        {JSONManager.MMTURIs.OnCircle, OnCircleFact.parseFact },
        {JSONManager.MMTURIs.AnglePlaneLine, AngleCircleLineFact.parseFact },
        {JSONManager.MMTURIs.RadiusCircleMetric, RadiusFact.parseFact },
        {JSONManager.MMTURIs.AreaCircle, AreaCircleFact.parseFact },
        {JSONManager.MMTURIs.OrthoCircleLine, OrthogonalCircleLineFact.parseFact },
        {JSONManager.MMTURIs.VolumeCone ,ConeVolumeFact.parseFact  },
        {JSONManager.MMTURIs.TruncatedVolumeCone ,TruncatedConeVolumeFact.parseFact  },
        {JSONManager.MMTURIs.RightAngle, RightAngleFact.parseFact },
        {JSONManager.MMTURIs.CylinderVolume, CylinderVolumeFact.parseFact },
        {JSONManager.MMTURIs.TestType, TestFact.parseFact },
        {JSONManager.MMTURIs.EqualityCircles, EqualCirclesFact.parseFact },
        {JSONManager.MMTURIs.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);
        return sendAdd(CommunicationEvents.ServerAdress + "/fact/add", body, out uri);
    }

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

        if (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 (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), "PointFact")]
[JsonSubtypes.KnownSubType(typeof(LineFact), "LineFact")]
[JsonSubtypes.KnownSubType(typeof(RayFact), "RayFact")]
[JsonSubtypes.KnownSubType(typeof(OnLineFact), "OnLineFact")]
[JsonSubtypes.KnownSubType(typeof(AngleFact), "AngleFact")]
[JsonSubtypes.KnownSubType(typeof(CircleFact), "CircleFact")]
[JsonSubtypes.KnownSubType(typeof(ParallelLineFact), "ParallelLine")]
[JsonSubtypes.KnownSubType(typeof(OnCircleFact), "OnCircleFact")]
[JsonSubtypes.KnownSubType(typeof(AngleCircleLineFact), "AnglePlaneLineFact")]
[JsonSubtypes.KnownSubType(typeof(AreaCircleFact), "AreaCircle")]
[JsonSubtypes.KnownSubType(typeof(RadiusFact), "RadiusCircleMetric")]
[JsonSubtypes.KnownSubType(typeof(OrthogonalCircleLineFact), "OrthogonalCircleLineFact")]
[JsonSubtypes.KnownSubType(typeof(ConeVolumeFact), "ConeVolumeFact")]
[JsonSubtypes.KnownSubType(typeof(TruncatedConeVolumeFact), "TruncatedConeVolumeFact")]
[JsonSubtypes.KnownSubType(typeof(RightAngleFact), "RightAngleFact")]
[JsonSubtypes.KnownSubType(typeof(CylinderVolumeFact), "CylinderVolumeFact")]
[JsonSubtypes.KnownSubType(typeof(TestFact), "TestFact")]
[JsonSubtypes.KnownSubType(typeof(EqualCirclesFact), "EqualCirclesFact")]
[JsonSubtypes.KnownSubType(typeof(UnEqualCirclesFact), "UnEqualCirclesFact")]
//[JsonSubtypes.KnownSubType(typeof(FunctionFact<T0, TResult>), "FunctionFact<T0, TResult>")] //TODO: generics?
[JsonSubtypes.KnownSubType(typeof(FunctionFact<float, float>), "FunctionFact<System.Single, System.Single>")]
[JsonSubtypes.KnownSubType(typeof(FunctionFact<float, 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; // Assembly.GetExecutingAssembly().GetTypes().Where(typeof(Fact).IsAssignableFrom).ToArray();

    /// <value>
    /// [ClassName] for JSON de-/serialization.
    /// Set in every non-abstract subclass of Fact.
    /// Also add JsonSubtypes.KnownSubType decorator for deserialization to Fact!
    /// </value>
    [JsonProperty]
    protected static /*new*/ string s_type = "ERROR: set s_type in T:Fact"; // In the subtype! NOT here!

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

    /// <summary>
    /// MMT URI
    /// </summary>
    protected string _URI;

    /// <value>
    /// <c>get</c> initiates and subsequently updates a human readable name. <remarks>Should be called once a constructor call to be initiated.</remarks>
    /// <c>set</c> calls <see cref="rename(string)"/>
    /// </value>
    public string Label
    {
        get
        { // in case of renamed dependables
            return (_Facts.GetNumberOfFacts() == 0 && this is not PointFact) // JsonSerialization toggle && allow first (Point)Fact to be created
                || (hasCustomLabel && _CustomLabel != null)
                ? _CustomLabel
                : generateLabel();
        }
        set { rename(value); }
    }

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

    /// <summary>
    /// Stores custom <see cref="Label"/> if set.
    /// </summary>
    protected string _CustomLabel = null;

    /// <summary>
    /// Counter to organize auto generated <see cref="Label"/>.
    /// Set to negative, if custom \ref Label is assigned.