using DG.Core;
using DG.EntityFramework;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using Zxd.Crm.Domain.Dto;
using Zxd.Crm.Domain.Impl;
using Zxd.Entity.Zxd;
using Zxd.EntityFramework;

namespace Zxd.Crm.Domain
{
    public class WarnningDomain : IWarnningDomain
    {
        private readonly IBaseRepository<ZxdDbContext> _zxdRepository;
        private readonly IMapper _mapper;

        public WarnningDomain(IBaseRepository<ZxdDbContext> zxdRepository,
            IMapper mapper)
        {
            _zxdRepository = zxdRepository;
            _mapper = mapper;
        }

        public async Task<bool> AddTemplate(WarnningTemplateCreateDto dto)
        {
            var query = _zxdRepository.GetRepository<EarlyWarningTemplate>();
            try
            {
                EarlyWarningTemplate template = new EarlyWarningTemplate();
                var postDetail = JsonHelper.FromJson<List<TemplateSettingDetail>>(dto.PrewarningValue);
                if (dto.Id > 0)
                {
                    template = await query.QueryIncluding(x => x.EarlyWarningSettings).FirstOrDefaultAsync(n => n.Id == dto.Id);
                    if (template != null)
                    {
                        var sameTime = dto.PeriodFrom == template.PeriodFrom && dto.PeriodTo == template.PeriodTo;
                    /*    if (!sameTime)
                        {
                            await query.DeleteAsync(template);
                            await CreateNewTemplate(dto);
                            return true;
                        }*/
                        var dbDetail = JsonHelper.FromJson<List<TemplateSettingDetail>>(template.PrewarningValue);
                        List<string> useGuid = new List<string>();
                        foreach (var item in postDetail)
                        {
                            var setDetail = postDetail.Where(n => n.type == item.type && n.value == item.value && !string.IsNullOrWhiteSpace(n.guid)).ToList();
                            var existDetail = dbDetail.FirstOrDefault(n => n.type == item.type && n.value == item.value && !useGuid.Contains(n.guid));
                            if (existDetail != null)
                            {
                                item.guid = existDetail.guid;
                                useGuid.Add(existDetail.guid);
                            }
                            else
                            {
                                item.guid = Guid.NewGuid().ToString();
                            }
                            if (string.IsNullOrWhiteSpace(item.guid) || !sameTime)
                            {
                                item.guid = Guid.NewGuid().ToString();
                            }
                        }
                        dto.PrewarningValue = postDetail.ToJson();
                        template.Count = dto.Count;
                        template.TemplateName = dto.TemplateName;
                        template.PeriodFrom = dto.PeriodFrom;
                        template.PeriodTo = dto.PeriodTo;
                        template.PrewarningValue = dto.PrewarningValue;
                        template.Deptid = dto.DeptId;
                        template.Maxnum = dto.Maxnum;
                        await query.UpdateAsync(template);
                        if (template.EarlyWarningSettings != null && template.EarlyWarningSettings.Any(x => x.MaxNum != dto.Maxnum))
                        {
                            template.EarlyWarningSettings.ForEach(setting => { setting.MaxNum = dto.Maxnum; });
                            await _zxdRepository.GetRepository<EarlyWarningSetting>().BatchUpdateAsync(template.EarlyWarningSettings, x => new { x.MaxNum });
                        }
                    }
                }
                else
                {
                    await CreateNewTemplate(dto);
                }

                return true;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        public async Task CreateNewTemplate(WarnningTemplateCreateDto dto)
        {
            var query = _zxdRepository.GetRepository<EarlyWarningTemplate>();
            var postDetail = JsonHelper.FromJson<List<TemplateSettingDetail>>(dto.PrewarningValue);
            foreach (var item in postDetail)
            {
                item.guid = Guid.NewGuid().ToString();
            }
            dto.PrewarningValue = postDetail.ToJson();
            var template = new EarlyWarningTemplate
            {
                Count = dto.Count,
                TemplateName = dto.TemplateName,
                PeriodFrom = dto.PeriodFrom,
                PeriodTo = dto.PeriodTo,
                PrewarningValue = dto.PrewarningValue,
                Deptid = dto.DeptId,
                Maxnum = dto.Maxnum,
            };
            await query.InsertAsync(template);
        }
        public async Task<PageResult<WarnningTemplateReturnModel>> GetTemplatePage(GetWarnningTemplateDto dto)
        {
            var query = _zxdRepository.GetRepository<EarlyWarningTemplate>().Query();
            if (!string.IsNullOrWhiteSpace(dto.Name))
            {
                query = query.Where(n => n.TemplateName.Contains(dto.Name));
            }
            if (dto.Id.HasValue)
            {
                query = query.Where(n => n.Id == dto.Id);
            }
            if (!string.IsNullOrWhiteSpace(dto.DeptId))
            {
                var deptFilter = dto.DeptId.Split(',').Select(n => Convert.ToInt32(n)).ToList();
                query = query.Where(n => deptFilter.Contains(n.Deptid));
            }
            var total = await query.CountAsync();
            query = query.OrderByDescending(n => n.Id);
            var res = await query
             .Skip((dto.PageIndex - 1) * dto.PageSize)
             .Take(dto.PageSize)
             .ToListAsync();
            var data = _mapper.Map<EarlyWarningTemplate, WarnningTemplateReturnModel>(res);
            return new PageResult<WarnningTemplateReturnModel>(dto.PageIndex, dto.PageSize, total, data);
        }

        public async Task<WarnningTemplateReturnModel> GetTemplate(int id)
        {
            var data = await _zxdRepository.GetRepository<EarlyWarningTemplate>().Query()
                .Where(x => x.Id == id)
                .FirstOrDefaultAsync();
            if (data == null) throw new ApiException("模板不存在或已删除！");
            return _mapper.Map<EarlyWarningTemplate, WarnningTemplateReturnModel>(data);
        }

        public async Task<List<WarnUserList>> GetWarnUserTotal(GetWarnningUserTotalDto dto)
        {
            var query = _zxdRepository.GetRepository<EarlyWarningUser>().Query();

            if (!string.IsNullOrWhiteSpace(dto.DeptId))
            {
                var deptFilter = dto.DeptId.Split(',').Select(n => Convert.ToInt32(n)).ToList();
                query = query.Where(n => deptFilter.Contains(n.Deptid));
            }
            var res = query.GroupBy(n => new
            {
                n.Code,
                n.Deptid,
                n.Participant
            }).Select(n => new WarnUserList
            {
                DeptId = n.Key.Deptid,
                Code = n.Key.Code,
                Count = n.Count(),
                Participant = n.Key.Participant
            }).ToList();

            foreach(var item in res)
            {
                if (string.IsNullOrEmpty(item.Code))
                {
                    var code = $"{CreateWarnUserNo()}";
                    item.Code = code;
                    var data = await _zxdRepository.GetRepository<EarlyWarningUser>().Query()
                        .Where(n => n.Deptid == item.DeptId && string.IsNullOrEmpty(n.Code))
                        .ToListAsync();
                    data.ForEach(x => { x.Code = code; });
                    await _zxdRepository.GetRepository<EarlyWarningUser>().BatchUpdateAsync(data);
                }
            }

            return res;
        }

        public async Task<EarlyWarningUserModel> GetWarnUser(string? code)
        {
            var res = await _zxdRepository.GetRepository<EarlyWarningUser>().Query().Where(n => n.Code == code).ToListAsync();
            if (res == null || !res.Any()) return new EarlyWarningUserModel();
            var data = res.First();
            EarlyWarningUserModel model = new()
            {
                Deptid = data.Deptid,
                WxWorkId = String.Join('\n', res.Select(n => n.WxWorkId)),
                Participant = data.Participant,
                Code = data.Code
            };
            return model;
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public async Task<bool> DeleteWarnUser(string? code)
        {
            var data = await _zxdRepository.GetRepository<EarlyWarningUser>().Query().Where(n => n.Code == code).ToListAsync();
            if (data.Any())
            {
                await _zxdRepository.GetRepository<EarlyWarningUser>().BatchDeleteAsync(data);
            }
            else
            {
                throw new ApiException("数据不存在！");
            }
            return true;
        }

        /// <summary>
        /// 新加告警配置
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<bool> AddWarnSetting(CreateOrEditSettingDto dto)
        {
            if (dto.DeptId == 0)
            {
                throw new Exception("业务线必填");
            }
            if (string.IsNullOrWhiteSpace(dto.Participant))
            {
                throw new Exception("人员必填");
            }
            var entryOp = _zxdRepository.GetRepository<EarlyWarningSetting>();
            var existList = entryOp.Query().Where(n => dto.WarnUserInfo.Select(n => n.Eid).Contains(n.Eid)).ToList();
            var userlist = dto.Participant.Split(',').ToList();
            var maxnum = dto.MaxNum.HasValue ? dto.MaxNum.Value : 0;
            if (dto.templateId.HasValue)
            {
                var template = await _zxdRepository.GetRepository<EarlyWarningTemplate>().Query()
                    .Where(x => x.Id == dto.templateId.Value)
                    .FirstOrDefaultAsync();
                if (template != null) maxnum = template.Maxnum;
            }
            foreach (var user in dto.WarnUserInfo)
            {
                var existModel = existList.FirstOrDefault(n => n.Eid == user.Eid);
                if (!dto.MaxNum.HasValue && dto.templateId.HasValue)
                {
                    throw new Exception("最大数量不能为空！");
                }
                if (existModel == null)
                {
                    if (!dto.templateId.HasValue)
                    {
                        //throw new Exception("模板不能为空");
                        continue;
                    }
                    EarlyWarningSetting model = new EarlyWarningSetting
                    {
                        Eid = Convert.ToInt32(user.Eid),
                        Name = user.Name,
                        TemplateId =  dto.templateId.HasValue ? dto.templateId:0,
                        Deptid = dto.DeptId,
                        CreateUser = dto.Eid,
                        CreateTime = DateTime.Now,
                        MaxNum = maxnum
                    };
                    await entryOp.InsertAsync(model);
                }
                else
                {
                    if (!dto.templateId.HasValue)
                    {
                        await entryOp.DeleteAsync(existModel);
                        continue;
                    }
                    existModel.TemplateId = dto.templateId;
                    existModel.Deptid = dto.DeptId;
                    existModel.CreateUser = dto.Eid;
                    existModel.UpdateTime = DateTime.Now;
                    existModel.HasChangeNum = maxnum > existModel.MaxNum ? 1 : 0;
                    existModel.MaxNum = maxnum;
                    await entryOp.UpdateAsync(existModel);
                }
            }
            return true;
        }

        public async Task<WarnningSetting> GetWarnSetting(GetWarnningSettingDto dto)
        {
            var entryOp = _zxdRepository.GetRepository<EarlyWarningSetting>();
            var templateList = _zxdRepository.GetRepository<EarlyWarningTemplate>().Query().Where(n => n.Deptid == dto.DeptId).ToList();
            var template = templateList.Map<EarlyWarningTemplate, TemplateSelectList>();
            /*var existList = entryOp.Query().Where(n => n.Deptid == deptId).ToList();
            if (existList.Count == 0)
            {
                return new WarnningSetting()
                {
                    DeptId = deptId,
                    Template = template
                };
            }
            var selTemplate = template.FirstOrDefault(n => n.Id == existList.FirstOrDefault().TemplateId);
            if (selTemplate != null)
            {
                selTemplate.selected = true;
            }*/
            WarnningSetting setting = new WarnningSetting()
            {
                //MaxNum = existList.FirstOrDefault().MaxNum,
                //templateId = existList.FirstOrDefault().TemplateId ,
                DeptId = dto.DeptId,
                //ParticipantIds = existList.Select(n => n.Eid.ToString()).ToList() ,
                Template = template
            };
            if (!string.IsNullOrWhiteSpace(dto.EidList))
            {
                var eidFilter = dto.EidList.Split(",").Select(n => Convert.ToDecimal(n)).ToList();
                var existList = entryOp.Query().Where(n =>n.Deptid == dto.DeptId && eidFilter.Contains(n.Eid)).GroupBy(n => new { maxNum = n.MaxNum, templateId = n.TemplateId }).
                    Select(n => new { maxNum = n.Key.maxNum, templateId = n.Key.templateId }).ToList();
                if (existList.Count == 1)
                {
                    setting.MaxNum = existList.FirstOrDefault().maxNum;
                    setting.templateId = existList.FirstOrDefault().templateId;
                    var selTemplate = setting.Template.FirstOrDefault(n => n.Id == existList.FirstOrDefault().templateId);
                    if (selTemplate != null)
                    {
                        selTemplate.selected = true;
                    }
                }
            }
            return setting;
        }

        public async Task<List<ReportListModel>> GetWarnSettingByEid(string eid)
        {
            List<ReportListModel> res = new List<ReportListModel>();
            var eidFilter = eid.Split(",").Select(n => Convert.ToDecimal(n)).ToList();
            var entryOp = _zxdRepository.GetRepository<EarlyWarningSetting>();
            var existList = entryOp.Query().Where(n => eidFilter.Contains(n.Eid)).ToList();
            var entryTemp = _zxdRepository.GetRepository<EarlyWarningTemplate>();
            var tempids = existList.Select(n => n.TemplateId).Distinct().ToList();
            var templateList = entryTemp.Query().Where(n => tempids.Contains(n.Id)).ToList();
            foreach (var eidItem in eidFilter)
            {
                var set = existList.FirstOrDefault(n => n.Eid == eidItem);
                if (set != null)
                {
                    var temp = templateList.FirstOrDefault(n => n.Id == set.TemplateId);
                    ReportListModel model = new ReportListModel
                    {
                        Eid = eidItem,
                        MaxNum = set.MaxNum,
                        Name = temp?.TemplateName
                    };
                    res.Add(model);
                }
            }
            return res;
        }

        public async Task<bool> AddWarnUser(EarlyWarningUserCreateDto dto, int? eid)
        {
            if (!dto.DeptId.HasValue)
            {
                throw new Exception("业务线必填");
            }
            if (string.IsNullOrWhiteSpace(dto.WxWorkId))
            {
                throw new Exception("企微Id必填");
            }
            var entryOp = _zxdRepository.GetRepository<EarlyWarningUser>();
            var code = dto.Code ?? CreateWarnUserNo();
            var existList = await entryOp.Query().Where(n => n.Code == dto.Code).ToListAsync();
            var _ids = dto.WxWorkId.Replace("\r\n", ",").Replace("\r", ",").Replace("\n", ",").Split(',').ToList();
            _ids = _ids.Distinct().ToList();
            if (dto.Type == 1 && existList.Count == 0)
            {
                code = CreateWarnUserNo();
                var data = await entryOp.Query().Where(x => x.Deptid == dto.DeptId).ToListAsync();

                foreach (var item in data)
                {
                    if (item.ParticipantIds.Intersect(dto.ParticipantIds).Any())
                    {
                        throw new Exception($"工号[{string.Join(",", item.ParticipantIds.Intersect(dto.ParticipantIds))}]被监视人员已存在，请勿重复创建！");
                    }
                }
            }
            else if (dto.Type == 2)
            {
                var data = await entryOp.Query().Where(x => x.Deptid == dto.DeptId && x.Code != dto.Code).ToListAsync();

                foreach (var item in data)
                {
                    if (item.ParticipantIds.Intersect(dto.ParticipantIds).Any())
                    {
                        throw new Exception($"工号[{string.Join(",", item.ParticipantIds.Intersect(dto.ParticipantIds))}]被监视人员已存在，请勿重复创建！");
                    }
                }
            }

            await entryOp.BatchDeleteAsync(existList);
            
            foreach (var item in _ids)
            {
                if (string.IsNullOrEmpty(item)) { continue; }
                EarlyWarningUser model = new EarlyWarningUser
                {
                    WxWorkId = item,
                    Deptid = dto.DeptId.Value,
                    CreateUser = eid?.ToString(),
                    CreateTime = DateTime.Now,
                    CropId = dto.Cropid,
                    AppId = dto.AppId,
                    Participant = dto.Participant,
                    Code = code
                };
                await entryOp.InsertAsync(model);
            }
            return true;
        }

        private string CreateWarnUserNo()
        {
            var no = $"{DateTimeOffset.Now.ToUnixTimeMilliseconds()}";
            return no;
        }

        public async Task<dynamic> GetNewTemplatePeriod(int deptid)
        {
            return await _zxdRepository.GetRepository<EarlyWarningTemplate>().Query()
                .Where(x => x.Deptid == deptid)
                .OrderByDescending(x => x.Id)
                .Select(x => new
                {
                    x.PeriodFrom,
                    x.PeriodTo
                })
                .FirstAsync();
        }
    }

    public class EarlyWarningTemplatePrewarningValue
    {
        [JsonPropertyName("type")]
        public int Type { get; set; }

        [JsonPropertyName("value")]
        public int Value { get; set; }
    }
}