using QM.KJGH.CGGL.IRepository;
using QM.KJGH.CGGL.Model.Enums;
using QM.KJGH.CGGL.Model.Ghxms;
using QM.KJGH.Model.KJGH;
using QM.OrmSqlSugar;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WS;
using WS.AutoMapper;
using WS.Orm;

namespace QM.KJGH.CGGL.Repository
{
    /// <summary>
    /// 
    /// </summary>
    public class GhbzGhxmRepository : SqlSugarRepository<GhbzGhxm>, IGhbzGhxmRepository
    {
        /// <summary>
        /// 检查
        /// </summary>
        /// <param name="bsm">标识码</param>
        /// <returns></returns>
        public async Task<GhbzGhxm> CheckId(string bsm)
        {
            var model = await GetAsync(t => t.BSM == bsm && t.IS_DELETE == KJGH.Model.EnumDelete.Mormal);
            if (model == null)
                throw new UseArgumentException("数据不存在，请检查标识码是否正确");
            return model;
        }

        /// <summary>
        /// 分页获取
        /// </summary>
        /// <returns></returns>
        public async Task<PageData> GetPage(GhbzGhxmPage input)
        {
            var query = DbClient().Queryable<GhbzGhxm>();

            if (!string.IsNullOrWhiteSpace(input.XMMC))
                query.Where((t) => t.XMMC.Contains(input.XMMC));
            if (!string.IsNullOrWhiteSpace(input.GHJB))
                query.Where((t) => t.GHJB == input.GHJB);
            if (!string.IsNullOrWhiteSpace(input.GHLX))
                query.Where((t) => t.GHLX == input.GHLX);
            if (!string.IsNullOrWhiteSpace(input.DQJD))
                query.Where((t) => t.DQJD == input.DQJD);

            var page = await query.OrderBy(t => t.BSM, SqlSugar.OrderByType.Desc).Where(t => t.IS_DELETE == KJGH.Model.EnumDelete.Mormal).ToPageAsync(input.page, input.limit);

            page.Data = (page.Data as List<GhbzGhxm>).MapTo<GhbzGhxm, GhbzGhxmListView>();
            return page;
        }

        /// <summary>
        /// 获取
        /// </summary>
        /// <param name="bsm">标识码</param>
        /// <returns></returns>
        public async Task<GhbzGhxmView> GetById(string bsm)
        {
            var model = (await CheckId(bsm)).MapTo<GhbzGhxmView>();
            return model;
        }

        /// <summary>
        /// 添加项目
        /// </summary>
        /// <param name="ghbzGhxmDto">请求参数</param>
        /// <returns></returns>
        public async Task<GhbzGhxm> Add(GhbzGhxmDto ghbzGhxmDto, string curUser)
        {
            if ((await GetAsync(t => t.XMBH == ghbzGhxmDto.XMBH)) != null)
                throw new UseArgumentException("数据已存在，项目编号重复!");

            var model = ghbzGhxmDto.MapTo<GhbzGhxm>();
            model.BSM = Guid.NewGuid().ToString("N");
            model.CTIME = DateTime.Now;
            model.CUSER = curUser;
            model.IS_DELETE = (int)StatusEnum.Mormal;
            var result = await InsertAsync(model);
            return result;
        }

        /// <summary>
        /// 修改项目信息
        /// </summary>
        /// <param name="ghbzGhxmDto"></param>
        /// <returns></returns>
        public async Task<bool> Update(GhbzGhxmDto ghbzGhxmDto)
        {
            var model = await CheckId(ghbzGhxmDto.BSM);
            var newmodel = ghbzGhxmDto.Map(model);
            var result = await UpdateAsync(newmodel);
            return result;
        }

        public async Task<bool> Delete(string bsm)
        {
            if (string.IsNullOrEmpty(bsm))
                throw new UseArgumentException("请求参数错误");

            //Expression<Func<GhbzGhxm, bool>> conditionwhere = i => i.BSM == bsm;
            var result = await UpdateAsync(u => new GhbzGhxm { IS_DELETE = KJGH.Model.EnumDelete.Deleted }, i => i.BSM == bsm);
            return result;
        }

        /// <summary>
        /// 根据标识码查看详细信息
        /// </summary>
        /// <param name="bsm"></param>
        /// <returns></returns>
        public async Task<GhbzGhxmDetailDto> Detail(string bsm)
        {
            var model = (await CheckId(bsm)).MapTo<GhbzGhxmDetailDto>();
            var query = DbClient();
            //进度情况
            var jddata = query.Queryable<GhbzGhxmJd>().Where(t => t.XM_BSM == bsm).ToList().MapTo<GhbzGhxmJd, GhbzGhxmJdDto>();
            jddata.ForEach(u =>
            {
                u.JDFJ = query.Queryable<GhbzGhxmJdfjb>().Where(t => t.GL_BSM == u.BSM).ToList();
            });
            //成果目录
            var cgmldata = query.Queryable<GhbzGhxmCgml>().ToList().MapTo<GhbzGhxmCgml, GhbzGhxmCgmlDto>();
            cgmldata.ForEach(u =>
            {
                u.CG = query.Queryable<GhbzGhxmCg>().Where(t => t.ML_BSM == u.BSM && t.XM_BSM == bsm && t.IS_DELETE == KJGH.Model.EnumDelete.Mormal).ToList().MapTo<GhbzGhxmCg, GhbzGhxmCgDto>();
            });
            model.JD = jddata;
            model.CGML = cgmldata;
            return model;
        }

        /// <summary>
        /// 根据分组类型统计
        /// </summary>
        /// <param name="ghlx">规划类型</param>
        /// <returns></returns>
        public StatisticsView GetStatistics(string ghlx)
        {


            var query = DbClient();



            //var project = query.Queryable<GhbzGhxm>().Where(u => u.GHLX == ghlx & u.IS_DELETE == StatusEnum.Mormal).ToList().MapTo<GhbzGhxm, GhbzGhxmListView>();
            ////取出该类型得ID
            //var bsms = project.Select(u => u.BSM);
            ////按照进度统计
            //var process = query.Queryable<GhbzGhxmJd>().Where(it => bsms.Contains(it.XM_BSM)).GroupBy(it => it.XMJD)
            //    .Select(it => new { xmjd = it.XMJD, count = SqlFunc.AggregateCount(it.BSM) }).ToList().ToDictionary(it => it.xmjd, it => it.count);

            //按照区域进度统计
            //var area = query.Queryable<GhbzGhxm, GhbzGhxmJd>((gg, jd) => new JoinQueryInfos(
            //   JoinType.Left, gg.BSM == jd.XM_BSM & gg.IS_DELETE == StatusEnum.Mormal & gg.GHLX == ghlx)).GroupBy((gg, jd) => new { gg.XZQMC, jd.XMJD })
            //   .Where((gg, jd) => gg.DQJD != null)
            //    .Select((gg, jd) => new { xzqmc = gg.XZQMC, xmjd = jd.XMJD, count = SqlFunc.AggregateCount(jd.BSM) })
            //    .ToList();

            //var list = GetList(t => t.GHLX == ghlx && t.DQJD != null & t.IS_DELETE == StatusEnum.Mormal).ToList().MapTo<GhbzGhxm, GhbzGhxmListView>();

            var list = query.Queryable<GhbzGhxm, CfgDict, GhbzGhxmJd>((gg, dic, jd) => new JoinQueryInfos(
               JoinType.Left, gg.DQJD == dic.ID, JoinType.Left, gg.DQJD == jd.XMJD && gg.BSM == jd.XM_BSM))
               .Where((gg, dic, jd) => gg.DQJD != null && gg.IS_DELETE == KJGH.Model.EnumDelete.Mormal && dic.TYPE == "项目进度" && gg.GHLX == ghlx)
               .OrderBy((gg, dic, jd) => dic.SORT)
                .Select((gg, dic, jd) => new GhbzGhxmListView()
                {
                    BSM = gg.BSM,
                    XMBH = gg.XMBH,
                    XMMC = gg.XMMC,
                    GHJB = gg.GHJB,
                    GHLX = gg.GHLX,
                    XZQDM = gg.XZQDM,
                    XZQMC = gg.XZQMC,
                    BZDW = gg.BZDW,
                    DQJD = gg.DQJD,
                    GHQX_KS = gg.GHQX_KS,
                    GHQX_JS = gg.GHQX_JS,
                    UpdateDate = jd.CTIME
                })
                .ToList();
            var piechart = list.GroupBy(t => t.DQJD).Select(t => new { name = t.Key, value = t.Count() }).ToList();

            var xzq = list.GroupBy(t => new { t.XZQDM, t.DQJD }).Select(t => new { xzqdm = t.Key.XZQDM, dqjd = t.Key.DQJD, c = t.Count() });

            var regionchart = list.GroupBy(t => new { t.XZQDM, t.XZQMC }).Select(t => new
            {
                xzqdm = t.Key.XZQDM,
                xzqmc = t.Key.XZQMC,
                value = new List<object>()
            }).ToList();

            foreach (var item in regionchart)
            {
                foreach (var item1 in piechart)
                {
                    var temp = xzq.Where(t => t.xzqdm == item.xzqdm && t.dqjd == item1.name).FirstOrDefault();
                    item.value.Add(new { name = item1.name, value = temp == null ? 0 : temp.c });
                }
            }

            return new StatisticsView
            {
                pieChart = piechart,
                regionChart = regionchart,
                ghbzGhxm = list
            };
        }
    }
}