using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Module.AzureCosmosDBV3;
using TEAMModelOS.Service.Models.Syllabus;
using TEAMModelOS.Service.Services.Syllabus.Interface;

namespace TEAMModelOS.Service.Services.Syllabus.Implement
{
    public class SyllabusService: ISyllabusService
    {
        private readonly IAzureCosmosDBV3Repository azureCosmosDBRepository;

        public SyllabusService(IAzureCosmosDBV3Repository azureCosmosDBRepository)
        {
            this.azureCosmosDBRepository = azureCosmosDBRepository;
        }


        /// <summary>
        /// 查找课纲 
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public async Task<List<SyllabusTree>> Find(Dictionary<string, object> request)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            foreach (KeyValuePair<string, object> keyValuePair in request)
            {
                dict.Add("children[*]." + keyValuePair.Key, keyValuePair.Value);
            }
            List<Syllabuses> data = await azureCosmosDBRepository.FindByDict<Syllabuses>(dict);
            List<SyllabusTree> treess = new List<SyllabusTree>();
            if (data.IsNotEmpty())
            {
                Dictionary<string, Syllabuses> syllabuses = new Dictionary<string, Syllabuses>();
                data.ForEach(x => syllabuses.TryAdd(x.id, x));
                data = new List<Syllabuses>(syllabuses.Values);
               
                foreach (Syllabuses item in data)
                {

                    List<SyllabusNode> nodedata = item.children;
                    if (request.TryGetValue("id", out object id))
                    {
                        foreach (SyllabusNode syllabus in nodedata)
                        {
                            if (syllabus.id == id.ToString())
                            {
                                List<SyllabusNode> nodes = new List<SyllabusNode>();
                                nodes.Add(syllabus);
                                await FindByPid(syllabus, nodes, nodedata);
                                nodedata = nodes;
                                break;
                            }
                        }
                    }
                    List<SyllabusTree> treess1 = ListToTree(nodedata);
                    treess.AddRange(treess1);

                    //treess.AddRange(treess1);
                }

               // return builder.Data(treess).build();
            }
            // else return builder.Data(data).build();
            return treess;

        }

        public static async Task<List<SyllabusNode>> FindByPid(SyllabusNode data, List<SyllabusNode> nodes, List<SyllabusNode> nodedata)
        {
            foreach (SyllabusNode syllabus in nodedata)
            {
                if (syllabus.pid == data.id)
                {
                    nodes.Add(syllabus);
                    await FindByPid(syllabus, nodes, nodedata);
                }
            }
            return nodes;
        }
        

        public async Task<List<Syllabuses>> SaveOrUpdateAsNodes(List<SyllabusNode> syllabusNodes)
        {
            List<Syllabuses> syllabuses = new List<Syllabuses>();

            List<Syllabuses> data = await azureCosmosDBRepository.FindByDict<Syllabuses>(new Dictionary<string, object> { { "id", syllabusNodes[0].volumeCode } });
            List<SyllabusNode> syllabusNodes1 = new List<SyllabusNode>();
            if (data.IsNotEmpty())
            {
                syllabusNodes1.AddRange(data[0].children);
                //replace
                for (int i = 0; i < data[0].children.Count; i++)
                {
                    for (int j = 0; j < syllabusNodes.Count; j++)
                    {
                        if (data[0].children[i].id == syllabusNodes[j].id && data[0].children[i].volumeCode == syllabusNodes[j].volumeCode)
                        {
                            syllabusNodes1.Remove(data[0].children[i]);
                            syllabusNodes1.Add(syllabusNodes[j]);
                            syllabusNodes.Remove(syllabusNodes[j]);
                        }
                    }
                }
                data[0].children = syllabusNodes1;

                //新增
                data[0].children.AddRange(syllabusNodes);


                syllabuses = await azureCosmosDBRepository.SaveOrUpdateAll<Syllabuses>(data);

            }
            else
            {
                throw new BizException("保存失败", ResponseCode.FAILED);
                //return builder.Error(false, ResponseCode.FAILED, "保存失败").build();
            }

            return syllabuses;
        }

        public async Task<List<SyllabusTree>> SaveOrUpdateAsTree(List<SyllabusTree> request)
        {
            List<SyllabusNode> nodes = new List<SyllabusNode>();
            Syllabuses syllabus = new Syllabuses();

            TreeToList(request, nodes);
            // List<SyllabusNode> nods = nodes.ToJson().FromJson<List<SyllabusNode>>() ;
            syllabus.children = nodes;
            syllabus.id = request[0].volumeCode;
            syllabus.volumeCode = request[0].volumeCode;
            await azureCosmosDBRepository.SaveOrUpdate<Syllabuses>(syllabus);
            List<SyllabusTree> treess = ListToTree(nodes);
            return treess;
        }

        public static List<SyllabusNode> TreeToList(List<SyllabusTree> trees, List<SyllabusNode> nodes)
        {
            trees = trees.OrderBy(x => x.order).ToList();
            nodes.AddRange(trees.ToJson().FromJson<List<SyllabusNode>>());

            foreach (SyllabusTree tree in trees)
            {
                if (null != tree.children && tree.children.Count > 0)
                {
                    TreeToList(tree.children, nodes);
                }
            }
            return nodes;
        }
        private static List<SyllabusTree> ListToTree(List<SyllabusNode> noes)
        {
            List<SyllabusTree> list = noes.ToJson().FromJson<List<SyllabusTree>>();
            //var lookup = list.ToDictionary(n => n.RowKey, n => n);

            var res = from r in list group r by r.id into g select g;
            Dictionary<string, SyllabusTree> blockDict = new Dictionary<string, SyllabusTree>();
            foreach (var s in res)
            {
                blockDict.TryAdd(s.First().id, s.First());
            }
            return GetChild(list, blockDict);
        }

        public static List<SyllabusTree> GetChild(List<SyllabusTree> list, Dictionary<string, SyllabusTree> dict)
        {
            //  list = list.OrderBy(m => m.Order).ToList();
            List<SyllabusTree> trees = new List<SyllabusTree>();
            foreach (SyllabusTree node in list)
            {
                bool flag = dict.TryGetValue(node.pid, out SyllabusTree syllabus);
                if (flag && syllabus != null)
                {
                    syllabus.children.Add(node);
                }
                else
                {
                    trees.Add(node);
                }
            }
            return trees;
        }

        public async Task<List<Syllabuses>> DeleteSyllabus(Dictionary<string, object> request)
        {
            Dictionary<string, object> dict = new Dictionary<string, object>();
            foreach (KeyValuePair<string, object> keyValuePair in request)
            {
                dict.Add("children[*]." + keyValuePair.Key, keyValuePair.Value);
            }

            List<Syllabuses> data = await azureCosmosDBRepository.FindByDict<Syllabuses>(dict);
            Dictionary<string, Syllabuses> syllabuses = new Dictionary<string, Syllabuses>();
            List<Syllabuses> data1 = new List<Syllabuses>();
            if (data.Count > 0)
            {
                data.ForEach(x => syllabuses.TryAdd(x.id, x));
                data = new List<Syllabuses>(syllabuses.Values);

                //是否全删
                bool flg = false;
                foreach (Syllabuses item in data)
                {
                    List<SyllabusNode> nodedata = item.children;
                    if (request.TryGetValue("id", out object id))
                    {
                        foreach (SyllabusNode syllabus in nodedata)
                        {
                            if (syllabus.id == id.ToString())
                            {
                                List<SyllabusNode> nodes = new List<SyllabusNode>();
                                nodes.Add(syllabus);
                                await FindByPid(syllabus, nodes, nodedata);
                                nodedata = nodes;
                                break;
                            }
                        }
                    }
                    List<SyllabusNode> syllabusNodes = new List<SyllabusNode>();
                    syllabusNodes.AddRange(item.children);
                    for (int i = 0; i < item.children.Count; i++)
                    {
                        for (int j = 0; j < nodedata.Count; j++)
                        {
                            if (item.children[i].id == nodedata[j].id)
                            {
                                syllabusNodes.Remove(item.children[i]);
                            }
                        }
                    }
                    item.children = syllabusNodes;
                    if (item.children.Count == 0)
                    {
                        await azureCosmosDBRepository.DeleteAsync<Syllabuses>(item.id, item.volumeCode);
                        flg = true;
                    }
                }
                if (!flg)
                {
                    data1 = await azureCosmosDBRepository.SaveOrUpdateAll<Syllabuses>(data);

                }


                //if (flg)
                //{

                //    return builder.Data("全部删除成功").build();
                //}
                //else
                //{
                //    List<Syllabuses> data1 = await azureCosmosDBRepository.SaveOrUpdateAll<Syllabuses>(data);
                //    return builder.Data(data1).build();
                //}


            }
            return data1;
        }
    }
}