using SqlSugar;
using System.ComponentModel;
using DS.Module.Core.Data;
using Newtonsoft.Json;

namespace DS.Module.Core.Extensions;

public static partial class Extensions
{
    /// <summary>
    /// 多排序方法
    /// </summary>
    /// <typeparam name="TEntity">要排序实体</typeparam>
    /// <param name="source">源</param>
    /// <param name="orderConditions">排序条件</param>
    /// <returns></returns>
    public static ISugarQueryable<TEntity> OrderBy<TEntity>(this ISugarQueryable<TEntity> source,
        SortCondition[] orderConditions)
    {
        orderConditions.NotNull(nameof(orderConditions));
        string orderStr = string.Empty;

        foreach (SortCondition orderCondition in orderConditions)
        {
            orderStr = orderStr +
                       $"{orderCondition.SortField} {(orderCondition.ListSortDirection == ListSortDirection.Ascending ? "asc" : "desc")}, ";
        }

        orderStr = orderStr.TrimEnd(", ".ToCharArray());
        return source.OrderBy(orderStr);
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="source"></param>
    /// <param name="page"></param>
    /// <typeparam name="TEntity"></typeparam>
    /// <returns></returns>
    public static DataResult<List<TEntity>> ToQueryPage<TEntity>(this ISugarQueryable<TEntity> source,
        PageCondition page)
    {
        page.NotNull(nameof(page));

        var result = source.WhereAsync(page.PageIndex, page.PageSize, page.SortConditions);
        var list = result.data;
        var total = result.totalNumber;
        return DataResult<List<TEntity>>.PageList(total, list, MultiLanguageConst.DataQuerySuccess);
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="source"></param>
    /// <param name="pageIndex"></param>
    /// <param name="pageSize"></param>
    /// <param name="orderConditions"></param>
    /// <typeparam name="TEntity"></typeparam>
    /// <returns></returns>
    private static (List<TEntity> data, int totalNumber) WhereAsync<TEntity>(this ISugarQueryable<TEntity> source,
        int pageIndex,
        int pageSize, SortCondition[] orderConditions)
    {
        var total = source.Count();

        ISugarQueryable<TEntity> orderSource;
        if (orderConditions == null || orderConditions.Length == 0)
        {
            // orderSource = source.OrderBy("Id ascending");
            orderSource = source.OrderBy("Id");
            // orderSource = source.OrderBy("GID");
        }
        else
        {
            orderSource = source.OrderBy(orderConditions);
        }

        source = orderSource;

        return (
            source.Count() != 0
                ? source.ToPageList(pageIndex, pageSize, ref total)
                : Enumerable.Empty<TEntity>().ToList(), total);
    }
    /// <summary>
    /// 转换SqlSugar条件查询表达式
    /// </summary>
    /// <param name="ruleStr"></param>
    /// <returns></returns>
    public static List<ConditionalCollections> ConvertSqlSugarExpression(this string ruleStr)
    {
        var conditions = JsonConvert.DeserializeObject<DataGroupConditions>(ruleStr);
        var conditionalCollections = new List<ConditionalCollections>();
        if (conditions.LogicalOperator == "and")
        {
            var conditionList = new List<KeyValuePair<WhereType, ConditionalModel>>();
            foreach (var item in conditions.Conditions)
            {
                conditionList.Add(new KeyValuePair<WhereType, ConditionalModel>
                    (WhereType.And,
                        new ConditionalModel
                        {
                            FieldName = item.Field, ConditionalType = GetConditionalType(item.Operator),
                            FieldValue = item.Value
                        })
                );
            }

            if (conditionList.Count > 0)
            {
                conditionalCollections.Add(new ConditionalCollections
                        {
                            ConditionalList = conditionList
                        }
                    )
                    ;
            }

            var groupList = new List<KeyValuePair<WhereType, ConditionalModel>>();
            foreach (var group in conditions.Groups)
            {
                if (group.LogicalOperator == "and")
                {
                    foreach (var item1 in group.Conditions)
                    {
                        groupList.Add(new KeyValuePair<WhereType, ConditionalModel>
                            (WhereType.And,
                                new ConditionalModel
                                {
                                    FieldName = item1.Field, ConditionalType = GetConditionalType(item1.Operator),
                                    FieldValue = item1.Value
                                })
                        );
                    }
                }
                else
                {
                    foreach (var item1 in group.Conditions)
                    {
                        groupList.Add(new KeyValuePair<WhereType, ConditionalModel>
                            (WhereType.Or,
                                new ConditionalModel
                                {
                                    FieldName = item1.Field, ConditionalType =GetConditionalType(item1.Operator),
                                    FieldValue = item1.Value
                                })
                        );
                    }
                }
            }

            if (groupList.Count > 0)
            {
                conditionalCollections.Add(new ConditionalCollections
                        {
                            ConditionalList = groupList
                        }
                    )
                    ;
            }
        }
        else
        {
            var conditionList = new List<KeyValuePair<WhereType, ConditionalModel>>();
            foreach (var item in conditions.Conditions)
            {
                conditionList.Add(new KeyValuePair<WhereType, ConditionalModel>
                    (WhereType.Or,
                        new ConditionalModel
                        {
                            FieldName = item.Field, ConditionalType = GetConditionalType(item.Operator),
                            FieldValue = item.Value
                        })
                );
            }

            if (conditionList.Count > 0)
            {
                conditionalCollections.Add(new ConditionalCollections
                        {
                            ConditionalList = conditionList
                        }
                    )
                    ;
            }

            var groupList = new List<KeyValuePair<WhereType, ConditionalModel>>();
            foreach (var group in conditions.Groups)
            {
                if (group.LogicalOperator == "and")
                {
                    foreach (var item1 in group.Conditions)
                    {
                        groupList.Add(new KeyValuePair<WhereType, ConditionalModel>
                            (WhereType.And,
                                new ConditionalModel
                                {
                                    FieldName = item1.Field, ConditionalType = GetConditionalType(item1.Operator),
                                    FieldValue = item1.Value
                                })
                        );
                    }
                }
                else
                {
                    foreach (var item1 in group.Conditions)
                    {
                        groupList.Add(new KeyValuePair<WhereType, ConditionalModel>
                            (WhereType.Or,
                                new ConditionalModel
                                {
                                    FieldName = item1.Field, ConditionalType = GetConditionalType(item1.Operator),
                                    FieldValue = item1.Value
                                })
                        );
                    }
                }
            }

            if (groupList.Count > 0)
            {
                conditionalCollections.Add(new ConditionalCollections
                        {
                            ConditionalList = groupList
                        }
                    )
                    ;
            }
        }

        return conditionalCollections;
    }
    
     /// <summary>
     ///  转换SqlSugar 条件操作符
     /// </summary>
     /// <param name="conditionalType"></param>
     /// <returns></returns>
    private static ConditionalType GetConditionalType(string conditionalType)
    {
        switch (conditionalType)
        {
            //等于
            case "equal":
                return ConditionalType.Equal;
            //不等于
            case "not_equal":
                return ConditionalType.NoEqual;
            //大于
            case "GreaterThan":
                return ConditionalType.GreaterThan;
            //大于等于
            case "GreaterThanOrEqual":
                return ConditionalType.GreaterThanOrEqual;
            //小于
            case "LessThan":
                return ConditionalType.LessThan;
            //小于等于
            case "LessThanOrEqual":
                return ConditionalType.GreaterThanOrEqual;
            //包含
            case "contains":
                return ConditionalType.In;
            //不包含
            case "not_contain":
                return ConditionalType.NotIn;
            //默认
            default:
                return ConditionalType.Equal;
        }
    }
}