using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Runtime.Serialization;
using System.Text.Json;

namespace InABox.Core
{
    public enum SortDirection
    {
        Ascending,
        Descending
    }

    public interface ISortOrder : ISerializeBinary
    {
        SortDirection Direction { get; set; }

        Expression Expression { get; set; }

        List<ISortOrder> Thens { get; }

        IEnumerable<String> ColumnNames();

        string AsOData();

        void SerializeBinary(CoreBinaryWriter writer);
        void DeserializeBinary(CoreBinaryReader reader);
    }

    public static class SortOrder
    {
        public static ISortOrder Create<T>(Type concrete, Expression<Func<T,object>> expression, SortDirection direction = SortDirection.Ascending)
        {
            if (!typeof(T).IsAssignableFrom(concrete))
                throw new Exception($"Columns: {concrete.EntityName()} does not implement {typeof(T).EntityName()}");
            var type = typeof(SortOrder<>).MakeGenericType(concrete);
            var property = CoreUtils.GetFullPropertyName(expression,".");
            var result = Activator.CreateInstance(type, property, direction );
            return (result as ISortOrder)!;
        }
    }
    
    public class SortOrder<T> : SerializableExpression<T>, ISortOrder // where T : Entity
    {
        public SortDirection Direction { get; set; }

        public List<SortOrder<T>> Thens { get; private set; }

        List<ISortOrder> ISortOrder.Thens => Thens.OfType<ISortOrder>().ToList();

        //public SortOrder<T> Ascending()
        //{
        //	Direction = SortOrder.Ascending;
        //	return this;
        //}

        //public SortOrder<T> Descending()
        //{
        //	Direction = SortOrder.Descending;
        //	return this;
        //}

        public SortOrder<T> ThenBy(Expression<Func<T, object?>> expression, SortDirection direction = SortDirection.Ascending)
        {
            var thenby = new SortOrder<T>(expression, direction);
            Thens.Add(thenby);
            return this;
        }

        #region Constructors

        public SortOrder()
        {
            Thens = new List<SortOrder<T>>();
            Direction = SortDirection.Ascending;
        }

        public SortOrder(Expression<Func<T, object?>> expression, SortDirection direction = SortDirection.Ascending)
            : base(expression)
        {
            Thens = new List<SortOrder<T>>();
            Direction = direction;
        }

        public SortOrder(string property, SortDirection direction = SortDirection.Ascending)
        {
            Thens = new List<SortOrder<T>>();
            Direction = direction;
            var iprop = DatabaseSchema.Property(typeof(T), property);
            Expression = iprop.Expression();
        }

        public SortOrder(SerializationInfo info, StreamingContext context)
        {
            Deserialize(info, context);
        }

        public static explicit operator SortOrder<T>(SortOrder<Entity> v)
        {
            if (v == null)
                return null;
            var json = Serialization.Serialize(v);
            json = json.Replace(typeof(Entity).EntityName(), typeof(T).EntityName());
            var result = Serialization.Deserialize<SortOrder<T>>(json);
            return result;
        }

        #endregion

        #region Display Functions

        public string AsOData()
        {
            var orderby = new Dictionary<SortDirection, string>
            {
                { SortDirection.Ascending, "asc" },
                { SortDirection.Descending, "desc" }
            };

            var prop = "";
            if (CoreUtils.TryFindMemberExpression(Expression, out var mexp))
                prop = CoreUtils.GetFullPropertyName(mexp, "/");
            else
                prop = Expression.ToString();

            var result = string.Format("{0} {1}", prop, orderby[Direction]);

            if (Thens != null && Thens.Count > 0)
                foreach (var then in Thens)
                {
                    var ThenResult = then.AsOData();
                    if (!string.IsNullOrEmpty(ThenResult))
                        result = string.Format("{0}, {1}", result, ThenResult);
                }

            return result;
        }

        public override string ToString()
        {
            return AsOData();
        }

        public IEnumerable<string> ColumnNames()
        {
            yield return CoreUtils.ExpressionToString(typeof(T), Expression);
            foreach (var then in Thens)
                foreach (var x in then.ColumnNames())
                    yield return x;
        }

        #endregion

        //public Expression<Func<T,Object>> AsExpression()
        //{
        //          var param = Expression.Parameter(typeof(T), "x");
        //          var result = Expression.Lambda<Func<T,Object>>(Expression,param);
        //	return result;
        //}

        #region Serialization

        public override void Serialize(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Direction", Direction.ToString());
            if (Thens.Count > 0)
                info.AddValue("Thens", Thens, typeof(List<SortOrder<T>>));
        }

        public override void Deserialize(SerializationInfo info, StreamingContext context)
        {
            Direction = (SortDirection)Enum.Parse(typeof(SortDirection), (string)info.GetValue("Direction", typeof(string)));
            try
            {
                Thens = (List<SortOrder<T>>)info.GetValue("Thens", typeof(List<SortOrder<T>>));
            }
            catch
            {
                Thens = new List<SortOrder<T>>();
            }
        }

        #endregion

        #region Binary Serialization

        public void SerializeBinary(CoreBinaryWriter writer)
        {
            writer.SerialiseExpression(typeof(T), Expression, false);
            writer.Write((byte)Direction);
            writer.Write(Thens.Count);
            foreach (var then in Thens)
            {
                then.SerializeBinary(writer);
            }
        }

        public void DeserializeBinary(CoreBinaryReader reader)
        {
            Expression = reader.DeserialiseExpression(typeof(T));
            Direction = (SortDirection)reader.ReadByte();

            Thens.Clear();
            var nThens = reader.ReadInt32();
            for(int i = 0; i < nThens; ++i)
            {
                var then = new SortOrder<T>();
                then.DeserializeBinary(reader);
                Thens.Add(then);
            }
        }

        #endregion
    }
    public static class SortOrderSerialization
    {
        /// <summary>
        /// Inverse of <see cref="Write{T}(CoreBinaryWriter, SortOrder{T}?)"/>.
        /// </summary>
        /// <param name="reader"></param>
        /// <returns></returns>
        public static SortOrder<T>? ReadSortOrder<T>(this CoreBinaryReader reader)
        {
            if (reader.ReadBoolean())
            {
                var sortOrder = new SortOrder<T>();
                sortOrder.DeserializeBinary(reader);
                return sortOrder;
            }
            return null;
        }

        /// <summary>
        /// Inverse of <see cref="ReadSortOrder{T}(CoreBinaryReader)"/>.
        /// </summary>
        /// <param name="filter"></param>
        /// <param name="writer"></param>
        public static void Write<T>(this CoreBinaryWriter writer, SortOrder<T>? sortOrder)
        {
            if (sortOrder is null)
            {
                writer.Write(false);
            }
            else
            {
                writer.Write(true);
                sortOrder.SerializeBinary(writer);
            }
        }
    }

    public class SortOrderJsonConverter : CustomJsonConverter<ISortOrder>
    {
        
        public override bool CanConvert(Type objectType)
        {
            if (objectType.IsConstructedGenericType)
            {
                var ot = objectType.GetGenericTypeDefinition();
                var tt = typeof(SortOrder<>);
                if (ot == tt)
                    return true;
            }

            return false;
        }

        public override ISortOrder? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            if (reader.TokenType == JsonTokenType.Null)
                return null;

            ISortOrder? result = null;
            var sType = "";
            var sExpr = "";
            var sDir = "";

            while (reader.TokenType != JsonTokenType.EndObject && reader.Read())
            {
                var tag = reader.GetString();
                reader.Read();
                if (string.Equals(tag, "$type"))
                {
                    sType = reader.GetString();
                    if (!string.IsNullOrWhiteSpace(sType))
                    {
                        var tType = Type.GetType(sType);
                        if (tType != null)
                        {
                            var gType = typeof(SortOrder<>).MakeGenericType(tType);
                            result = Activator.CreateInstance(gType) as ISortOrder;
                        }
                    }
                }
                else if (string.Equals(tag, "Expression") && result != null)
                    sExpr = reader.GetString();
                else if (string.Equals(tag, "Direction") && result != null)
                    sDir = reader.GetString();
                else if (string.Equals(tag, "Thens") && result != null)
                {
                    reader.Read();
                    while (reader.TokenType != JsonTokenType.EndObject)
                    {
                        var then = Read(ref reader, typeof(ISortOrder), options);
                        if (then != null)
                            result.Thens.Add(then);
                    }
                }

                
            }
            return result;
        }

        public override void Write(Utf8JsonWriter writer, ISortOrder value, JsonSerializerOptions options)
        {
            var type = value.GetType().GenericTypeArguments[0];
            
            var property = CoreUtils.GetPropertyValue(value, "Expression") as MemberExpression;
            var prop = CoreUtils.ExpressionToString(type, property, true);
            var dir = CoreUtils.GetPropertyValue(value, "Direction")?.ToString() ?? nameof(SortDirection.Ascending);

            writer.WriteStartObject();
            
            writer.WriteString("$type",value.GetType().FullName);
            writer.WriteString("Expression",prop);
            writer.WriteString("Direction",dir);

            if (CoreUtils.GetPropertyValue(value, "Thens") is IEnumerable<ISortOrder> thens)
            {
                writer.WritePropertyName("Thens");
                writer.WriteStartArray();
                foreach (var then in thens)
                    Write(writer,then,options);
                writer.WriteEndArray();
            }

            writer.WriteEndObject();
        }
    }
}