SOMDocs.cs

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

namespace REST_JSON_API
{
    [JsonConverter(typeof(JsonSubtypes), "kind")]
    [JsonSubtypes.KnownSubType(typeof(OMA), "OMA")]
    [JsonSubtypes.KnownSubType(typeof(OMBINDC), "OMBINDC")]
    [JsonSubtypes.KnownSubType(typeof(OMS), "OMS")]
    [JsonSubtypes.KnownSubType(typeof(OMSTR), "OMSTR")]
    [JsonSubtypes.KnownSubType(typeof(OMF), "OMF")]
    [JsonSubtypes.KnownSubType(typeof(OMV), "OMV")]
    [JsonSubtypes.KnownSubType(typeof(RAW), "RAW")]
    //[JsonSubtypes.KnownSubType(typeof(OMC<T>), "OMC<" + typeof(T) + ">")]
    [JsonSubtypes.KnownSubType(typeof(OMC<Vector3>), "OMC<UnityEngine.Vector3>")]
    [JsonSubtypes.KnownSubType(typeof(OMC<float>), "OMC<System.Single>")]
    [JsonSubtypes.KnownSubType(typeof(OMC<double>), "OMC<System.Double>")]
    abstract public partial class SOMDoc
    {
        public string kind;

        protected SOMDoc() { kind = this.GetType().Name; }

        public SOMDoc TypeOf()
            => TypeOf(new SOMDoc[0]);

        protected internal abstract SOMDoc TypeOf(SOMDoc[] args);

        public static bool Equivalent(SOMDoc sd1, SOMDoc sd2)
            => sd1 != null && sd2 != null
            && sd1.Equivalent(sd2);

        public abstract bool Equivalent(SOMDoc sd2);

        public LambdaExpression PartialInvokeCastingLambdaExpression(out Type[] signature_args, object[] callArgs = null, bool[] useArgs = null)
        {
            LambdaExpression lambda_orig = GetLambdaExpression();

            signature_args = new Type[lambda_orig.Parameters.Count + 1];

            ParameterExpression object_arr = Expression.Parameter(typeof(object[]), "PARAMS_Arr");
            Expression[] cast_new_to_signature = new Expression[lambda_orig.Parameters.Count];

            int n_params = 0;
            for (int i = 0; i < lambda_orig.Parameters.Count; i++)
            {
                if (callArgs != null && callArgs.Length < i
                 && (useArgs == null || (useArgs.Length < i && useArgs[i])))
                {
                    cast_new_to_signature[i] =
                        Expression.Constant(callArgs[i], lambda_orig.Parameters[i].Type);
                    continue;
                }

                signature_args[n_params++] = lambda_orig.Parameters[i].Type;

                cast_new_to_signature[i] =
                    Expression.Convert(
                        Expression.ArrayIndex(
                            object_arr,
                            Expression.Constant(i)
                        ),
                        lambda_orig.Parameters[i].Type
                    );
            }
            signature_args[n_params] = lambda_orig.ReturnType;
            signature_args = signature_args.Slice(0, n_params + 1).ToArray();

            return Expression.Lambda(
                typeof(Array).IsAssignableFrom(lambda_orig.ReturnType)
                    ? Expression.Convert(
                        Expression.Invoke(lambda_orig, cast_new_to_signature),
                        typeof(object[]))
                    : Expression.NewArrayInit(
                        typeof(object),
                        new Expression[] { Expression.Convert(Expression.Invoke(lambda_orig, cast_new_to_signature), typeof(object)) }),

                object_arr
                );
        }

        public LambdaExpression GetLambdaExpression()
            => GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], new ParameterExpression[0]);

        protected internal abstract LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params);

        public abstract override string ToString();

        public abstract SOMDoc MapURIs(Dictionary<string, string> old_to_new);

        #region MakeMMT_OMS_URItoSOMDoc
        public static OMA MakeTupel(Vector3 vec)
            => MakeTupel(new[] {
                        new OMF(vec.x),
                        new OMF(vec.y),
                        new OMF(vec.z),
                });

        public static OMA MakeTupel(SOMDoc[] args)
            => new(
                    new OMS(MMTConstants.Tuple),
                    args
                );

        public static OMA MakeShallowList(SOMDoc[] args)
            => new(
                    new OMS(MMTConstants.ListApplicant),
                    args
                );

        public static OMA MakeDeepList(SOMDoc[] args, SOMDoc typeURI)
        {
            SOMDoc[] end_of_list = new SOMDoc[] {
                new OMA(
                    new OMS(MMTConstants.ListEnd),
                    new[] {
                        typeURI,
                    }
                ),
                args.Length == 0
                    ? null
                    : args[^1]
            };

            if (args.Length == 0)
                end_of_list = end_of_list[..^0];

            SOMDoc defines = new OMA(
                new OMS(MMTConstants.ListLiteral),
                end_of_list
            );

            for (int i = args.Length - 2; i >= 0; i--)
            {
                defines = new OMA(
                    new OMS(MMTConstants.ListLiteral),
                    new[] {
                        defines,
                        args[i],
                });
            }

            SOMDoc type = new OMA(
                new OMS(MMTConstants.ListApplicant),
                new[] { typeURI }
            );

            return new OMA(type, new[] { defines });
        }
        #endregion MakeMMT_OMS_URItoSOMDoc
    }

    public abstract class SOMDocCRTP<T> : SOMDoc where T : SOMDocCRTP<T>
    {
        protected SOMDocCRTP() : base() { }

        public override bool Equivalent(SOMDoc sd2)
            => this.GetType() == sd2.GetType() && (this as T).EquivalentWrapped(sd2 as T);

        protected abstract bool EquivalentWrapped(T sd2);

        public override SOMDoc MapURIs(Dictionary<string, string> old_to_new)
            => MapURIsWrapped(old_to_new);

        protected abstract T MapURIsWrapped(Dictionary<string, string> old_to_new);
    }

    public class OMBINDC : SOMDocCRTP<OMBINDC>
    {
        public new string kind = "OMBINDC";

        public string name;

        public SOMDoc lambdabody;

        /// <summary>@Type of this variable</summary>
        [JsonIgnore]
        public Type type;

        /// <summary>Enables (especially <see cref="JsonConverter"/>) to read and set <see cref="type"/> by its <c>string</c> representation.</summary>
        public string typeString
        {
            get => MMTConstants.TYPE_TO_OMS[type];
            set => type = MMTConstants.OMS_TO_TYPE[value];
        }

        [JsonConstructor]
        public OMBINDC(string name, string typeString, SOMDoc lambdabody) : base()
        {
            this.name = name;
            this.typeString = typeString;
            this.lambdabody = lambdabody;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => throw new NotImplementedException();

        public OMBINDC(string name, Type type, SOMDoc lambdabody) : base()
        {
            this.name = name;
            this.type = type;
            this.lambdabody = lambdabody;
        }

        protected override bool EquivalentWrapped(OMBINDC sd2)
            => this.type == sd2.type
            && this.name.Equals(sd2.name)
            && this.lambdabody.Equivalent(sd2.lambdabody);

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
        {
            ParameterExpression[] bind_me = bound_params.ShallowCloneAppend(
                new[] { Expression.Parameter(type, name) }
            );

            return lambdabody.GetLambdaExpression(lambda_applicant, lambda_arguments, bind_me);
        }

        public override string ToString()
            => "OMBINDC(" + name + ", " + typeString + ")->";

        protected override OMBINDC MapURIsWrapped(Dictionary<string, string> old_to_new)
            => new(name, type, lambdabody.MapURIs(old_to_new));
    }

    public class OMA : SOMDocCRTP<OMA>
    {
        public new string kind = "OMA";

        public SOMDoc applicant;
        public SOMDoc[] arguments;

        [JsonConstructor]
        public OMA(SOMDoc applicant, SOMDoc[] arguments) : base()
        {
            this.applicant = applicant;
            this.arguments = arguments;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => applicant.TypeOf(arguments.Select(a => a.TypeOf()).ToArray());

        protected override bool EquivalentWrapped(OMA sd2)
            => Equivalent(this.applicant, sd2.applicant)
            && this.arguments
                .Zip(sd2.arguments, (arg1, arg2) => Equivalent(arg1, arg2))
                .All(b => b);

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant_paps, LambdaExpression[] lambda_applicant_grands, ParameterExpression[] bound_params)
            => applicant.GetLambdaExpression(
                arguments.Select(arg => arg.GetLambdaExpression(new LambdaExpression[0], new LambdaExpression[0], bound_params)).ToArray(),
                lambda_applicant_paps,
                bound_params
            );

        public override string ToString()
            => applicant.ToString() + "(" + string.Join(", ", arguments.Select(a => a.ToString())) + ")";

        protected override OMA MapURIsWrapped(Dictionary<string, string> old_to_new)
            => new OMA(
                applicant.MapURIs(old_to_new),
                arguments.Select(arg => arg.MapURIs(old_to_new)).ToArray()
            );
    }

    public class OMS : SOMDocCRTP<OMS>
    {
        public new string kind = "OMS";

        public string uri;

        [JsonConstructor]
        public OMS(string uri) : base()
        {
            this.uri = uri;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
        {
            if (FactOrganizer.AllFacts.TryGetValue(uri, out Fact found))
                return new OMS(MMTConstants.TYPE_TO_OMS[found.GetType()]);

            if (MMTConstants.HeterogenApplication_TO_TypeOF.TryGetValue(uri, out string type))
                return new OMA(
                    new OMS(type),
                    args
                );

            if (MMTConstants.HomogenApplication_TO_TypeOF.TryGetValue(uri, out type))
                return new OMA(
                    new OMS(type),
                    new[] { args[0] }
                );

            if (MMTConstants.URI_TO_TypeOF.TryGetValue(uri, out type))
                return new OMS(type);

            throw new NotImplementedException();
        }

        protected override bool EquivalentWrapped(OMS sd2)
            => this.uri == sd2.uri;

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
            => SOMDocToLambdaExpression<float>.MakeLambdaExpression(uri, lambda_applicant, lambda_arguments, bound_params);

        public override string ToString()
            => uri;

        protected override OMS MapURIsWrapped(Dictionary<string, string> old_to_new)
        {
            if (!old_to_new.TryGetValue(uri, out string new_uri))
                new_uri = uri;

            return new OMS(new_uri);
        }
    }

    public class OMSTR : SOMDocCRTP<OMSTR>
    {
        public new string kind = "OMSTR";

        [JsonProperty("float")]
        public string s;

        [JsonConstructor]
        public OMSTR(string s) : base()
        {
            this.s = s;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => throw new NotImplementedException();

        protected override bool EquivalentWrapped(OMSTR sd2)
            => this.s == sd2.s;

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
            => Expression.Lambda(Expression.Constant(s, typeof(string)), null);

        public override string ToString()
            => s;

        protected override OMSTR MapURIsWrapped(Dictionary<string, string> old_to_new)
            => (OMSTR)this.MemberwiseClone();
    }

    public class OMF : SOMDocCRTP<OMF>
    {
        public new string kind = "OMF";

        [JsonProperty("float")]
        public float @float;

        [JsonConstructor]
        public OMF(float f) : base()
        {
            this.@float = f;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => new OMS(MMTConstants.RealLit);

        protected override bool EquivalentWrapped(OMF sd2)
            => Mathf.Approximately(@float, sd2.@float);

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
            => Expression.Lambda(Expression.Constant(@float, typeof(float)), null);

        public override string ToString()
            => @float.ToString();

        protected override OMF MapURIsWrapped(Dictionary<string, string> old_to_new)
            => (OMF)this.MemberwiseClone();
    }

    public class OMC<T> : SOMDocCRTP<OMC<T>>
    {
        public new string kind = "OMC<" + typeof(T) + ">";

        public T value;

        [JsonConstructor]
        public OMC(T value) : base()
        {
            this.value = value;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => new OMS(MMTConstants.TYPE_TO_OMS[typeof(T)]);

        protected override bool EquivalentWrapped(OMC<T> sd2)
        {
            Debug.LogWarning("Cannot check Equivalency for " + this.GetType() + "; only whether it's exact!");
            return this.value.Equals(value);
        }

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
            => Expression.Lambda(Expression.Constant(value, typeof(T)), null);

        public override string ToString()
            => "C_" + typeof(T) + "(" + value.ToString() + ")";

        protected override OMC<T> MapURIsWrapped(Dictionary<string, string> old_to_new)
            => (OMC<T>)this.MemberwiseClone();
    }

    public class OMV : SOMDocCRTP<OMV>
    {
        public new string kind = "OMV";

        public string name;

        [JsonConstructor]
        public OMV(string name) : base()
        {
            this.name = name;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => throw new NotImplementedException();

        protected override bool EquivalentWrapped(OMV sd2)
            => this.name == sd2.name;

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
        {
            ParameterExpression v = bound_params.FirstOrDefault(param => param.Name.Equals(name));
            if (v == null)
            {
                Debug.LogErrorFormat("Unable to find {0} for {1} with name: {2}", nameof(OMBINDC), nameof(OMV), name);
                return Expression.Lambda(Expression.Empty(), null);
            }
            else
                return Expression.Lambda(v, new[] { v });
        }

        public override string ToString()
            => "Variable_" + "(" + name + ")";

        protected override OMV MapURIsWrapped(Dictionary<string, string> old_to_new)
            => (OMV)this.MemberwiseClone();
    }

    public class RAW : SOMDocCRTP<RAW>
    {
        public new string kind = "RAW";

        public string xml;

        [JsonConstructor]
        public RAW(string xml) : base()
        {
            this.xml = xml;
        }

        protected internal override SOMDoc TypeOf(SOMDoc[] args)
            => throw new NotImplementedException();

        protected override RAW MapURIsWrapped(Dictionary<string, string> old_to_new)
        {
            string copy = xml;
            foreach (KeyValuePair<string, string> KeyVal in old_to_new)
                copy = copy.Replace(KeyVal.Key, KeyVal.Value);

            return new RAW(copy);
        }

        public override string ToString()
            => xml;

        protected override bool EquivalentWrapped(RAW sd2)
            => throw new NotImplementedException(); //xml == sd2.xml; // only exact

        protected internal override LambdaExpression GetLambdaExpression(LambdaExpression[] lambda_applicant, LambdaExpression[] lambda_arguments, ParameterExpression[] bound_params)
        {
            throw new NotImplementedException();
        }
    }
}