using JNPF.Common.Core.Manager;
using JNPF.Common.Dtos.Message;
using JNPF.Common.Enums;
using JNPF.Common.Filter;
using JNPF.Common.Security;
using JNPF.DependencyInjection;
using JNPF.DynamicApiController;
using JNPF.FriendlyException;
using JNPF.Message.Entitys.Entity;
using JNPF.Message.Service;
using JNPF.Systems.Entitys.Permission;
using JNPF.TaskScheduler;
using JNPF.TaskScheduler.Entitys.Dto.TaskScheduler;
using JNPF.TaskScheduler.Entitys.Model;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using Tnb.ProductionMgr.Entities;
using Tnb.ProductionMgr.Entities.Dto;
using Tnb.ProductionMgr.Entities.Dto.PrdManage;
using Tnb.ProductionMgr.Entities.Entity;
using Tnb.ProductionMgr.Interfaces;
using Tnb.BasicData.Entities;
using JNPF.Systems.Entitys.System;
using JNPF.Message.Entitys.Entity;
using Tnb.BasicData;
using Tnb.BasicData.Interfaces;
using MessageTemplateEntity = JNPF.Message.Entitys.Entity.MessageTemplateEntity;

namespace Tnb.ProductionMgr
{
    [ApiDescriptionSettings(Tag = ModuleConst.Tag, Area = ModuleConst.Area, Order = 700)]
    [Route("api/[area]/[controller]/[action]")]
    public class AndonRecordService: IAndonRecordService, IDynamicApiController, ITransient
    {
        private readonly ISqlSugarClient _db;
        private readonly IUserManager _userManager;
        private SendMessageService _sendMessageService;
        private readonly IBasPushRuleLogService _basPushRuleLogService;
        private readonly TimeTaskService _timeTaskService;
        
        public AndonRecordService(ISqlSugarRepository<AndonRecords> repository,
            SendMessageService sendMessageService,
            TimeTaskService timeTaskService,
            IBasPushRuleLogService basPushRuleLogService,
            IUserManager userManager)
        {
            _userManager = userManager;
            _sendMessageService = sendMessageService;
            _timeTaskService = timeTaskService;
            _basPushRuleLogService = basPushRuleLogService;
            _db = repository.AsSugarClient();
        }

        [HttpPost]
        public async Task<dynamic> GetAndonPadList(AndonPadListInput input)
        {
            var result = await _db.Queryable<AndonRecords>()
                .LeftJoin<AndonInfo>((a, b) => a.andon_info_id == b.id)
                .LeftJoin<UserEntity>((a, b, c) => a.repair_id == c.Id)
                .LeftJoin<UserEntity>((a, b, c, d) => a.create_id == d.Id)
                .LeftJoin<DictionaryTypeEntity>((a,b,c,d,e)=>e.EnCode==DictConst.AndonStatus)
                .LeftJoin<DictionaryDataEntity>((a,b,c,d,e,f)=>a.status==f.EnCode && e.Id==f.DictionaryTypeId)
                .Where((a, b, c, d) => a.andon_type_id == input.andon_type_id)
                .WhereIF(!string.IsNullOrEmpty(input.status),(a, b, c, d)=>a.status==input.status)
                .Select((a, b, c, d,e,f) => new AndonPadListOutput
                {
                    id = a.id,
                    andon_info_name = b.name,
                    promoter_name = d.RealName,
                    repair_name = c.RealName,
                    promoter_time = a.create_time == null ? "" : a.create_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
                    response_time = a.response_time == null ? "" : a.response_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
                    start_repair_time = a.start_repair_time == null ? "" : a.start_repair_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
                    end_repair_time = a.end_repair_time == null ? "" : a.end_repair_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
                    confirm_time = a.confirm_time == null ? "" : a.confirm_time.Value.ToString("yyyy-MM-dd hh:mm:ss"),
                    status = f.FullName,
                }).ToPagedListAsync(input.currentPage, input.pageSize);

            return PageResult<AndonPadListOutput>.SqlSugarPageResult(result);

        }

        [HttpPost]
        public async Task<dynamic> AddAndon(AddAndonInput input)
        {
            AndonInfo andonInfo = await _db.Queryable<AndonInfo>().SingleAsync(x => x.id == input.andon_info_id);
            AndonRecords andonRecords = input.Adapt<AndonRecords>();
            DbResult<bool> result =  await _db.Ado.UseTranAsync(async () =>
            {
                
                andonRecords.create_time = DateTime.Now;
                andonRecords.create_id = _userManager.UserId;
                andonRecords.status = DictConst.AndonStatusHJZ;

                
                List<string> toUsers = new List<string>();

                if (!string.IsNullOrEmpty(andonInfo.personnel))
                {
                    toUsers.AddRange(JsonConvert.DeserializeObject<List<string>>(andonInfo.personnel));
                }
                        
                if (!string.IsNullOrEmpty(andonInfo.position))
                {
                            
                    toUsers.AddRange(_db.Queryable<UserRelationEntity>().Where(x => andonInfo.position.Contains(x.Id)).Select(s => s.UserId).ToList());
                }
                        
                if (!string.IsNullOrEmpty(andonInfo.role))
                {
                            
                    toUsers.AddRange(_db.Queryable<UserRelationEntity>().Where(x => andonInfo.role.Contains(x.Id)).Select(s => s.UserId).ToList());
                }

                if (toUsers.Count() > 0)
                {
                    List<MessageSendModel> list = await _sendMessageService.SendTest(andonInfo.send_config_id);

                    foreach (var item in list)
                    {
                        item.toUser = toUsers;
                    }

                    foreach (var item in list)
                    {
                        await _sendMessageService.SendMessage(item, new Dictionary<string, object>());
                    }
                }

                await _db.Insertable<AndonRecords>(andonRecords).ExecuteCommandAsync();

            });
            
            if (result.IsSuccess)
                {
                    BasPushRuleH basPushRuleH = await _db.Queryable<BasPushRuleH>().SingleAsync(x=>x.id==andonInfo.push_rule_id);
                    BasPushRuleD basPushRuleD = await _db.Queryable<BasPushRuleD>().FirstAsync(x => x.push_rule_id == andonInfo.push_rule_id && x.ordinal == 1);
                    if (basPushRuleH?.enabled == 1)
                    {
                        string sendConfigId = basPushRuleD?.send_config_id ?? "";
                        List<MessageSendModel> sendModels = await GetSendParamJson(sendConfigId);
                        
                        if (sendModels != null && sendModels.Count > 0)
                        {
                            DateTime executeTime = DateTime.Now.AddMinutes(basPushRuleD.interval);
                            // string cron = $"0 {executeTime.Minute} {executeTime.Hour} {executeTime.Day} {executeTime.Month} ? {executeTime.Year}";
                            string cron = $"0 {executeTime.Minute} {executeTime.Hour} {executeTime.Day} {executeTime.Month} ?";
                        
                            var comtentModel = new ContentModel();
                            // comtentModel.cron = (2 * 60).ToString();
                            comtentModel.cron = cron;
                            comtentModel.interfaceId = "";
                            comtentModel.interfaceName = "";
                            comtentModel.parameter = new List<InterfaceParameter>();
                            comtentModel.localHostTaskId = "PushMsgTimeWorker/PushMsg";
                            comtentModel.startTime = DateTimeOffset.Now.ToUnixTimeMilliseconds();
                            // comtentModel.endTime = DateTimeOffset.Now.AddSeconds(3).ToUnixTimeMilliseconds().ToString();
                            comtentModel.TenantId = _userManager?.TenantId;
                            comtentModel.TenantDbName = _userManager?.TenantDbName;
                            comtentModel.ConnectionConfig = _userManager?.ConnectionConfig;
                            comtentModel.Token = _userManager?.ToKen;
                            
                            // foreach (var item in sendModels)
                            // {
                            // }
                            //
                            TimeTaskCrInput timeTaskCrInput = new TimeTaskCrInput()
                            {
                                enCode = DateTime.Now.ToString("yyyyMMddHHmmss"),
                                fullName = "andon推送消息" + DateTime.Now.ToString("yyyyMMddHHmmss"),
                                executeType = "3",
                                executeContent = comtentModel.ToJsonString(),
                                description = JsonConvert.SerializeObject(sendModels[0].paramJson),
                                sortCode = 9999,
                                enabledMark = 1,
                            };

                            await _timeTaskService.Create(timeTaskCrInput,false);

                            TimeTaskEntity timeTaskEntity = await _db.Queryable<TimeTaskEntity>().Where(x => x.EnCode == timeTaskCrInput.enCode).FirstAsync();
                            
                            BasPushRuleLog basPushRuleLog = new BasPushRuleLog()
                            {
                                push_rule_id = andonInfo.push_rule_id,
                                timetask_id = timeTaskEntity?.Id,
                                biz_id = andonRecords.id,
                                ordinal = 1,
                                is_push = 1,
                            };

                            await _db.Insertable<BasPushRuleLog>(basPushRuleLog).ExecuteCommandAsync();
                        }
                    }
                    
                }
           
            if(!result.IsSuccess) throw Oops.Oh(ErrorCode.COM1008);
            return result.IsSuccess ? "发起成功" : result.ErrorMessage;
        }

        [HttpPost]
        public async Task<dynamic> ResponseAndon(Dictionary<string,string> dic)
        {
            string id = dic.ContainsKey("id") ? dic["id"] : "";
            AndonRecords andonRecords = await _db.Queryable<AndonRecords>().SingleAsync(x => x.id == id);
            if (andonRecords != null)
            {
                if (!string.IsNullOrEmpty(andonRecords.repair_id))
                {
                    UserEntity user = await _db.Queryable<UserEntity>().SingleAsync(x => x.Id == andonRecords.repair_id);
                    throw Oops.Bah($"{user.RealName}已响应");
                }
                else
                {
                    if (andonRecords.status != DictConst.AndonStatusHJZ)
                    {
                        throw Oops.Bah($"状态错误");  
                    }
                    else
                    {
                        await _db.Updateable<AndonRecords>()
                            .SetColumns(x => x.repair_id == _userManager.UserId)
                            .SetColumns(x=>x.response_time==DateTime.Now)
                            .ExecuteCommandAsync();
                        Dictionary<string, string> postData = new Dictionary<string, string>()
                        {
                            ["id"] = andonRecords.id
                        };
                        await _basPushRuleLogService.Stop(postData);
                        return true;
                    }
                    
                    
                }
            }
            else
            {
                throw Oops.Bah($"无该andon记录");  
            }
        }

        [HttpPost]
        public async Task<dynamic> StartAndon(Dictionary<string, string> dic)
        {
            string id = dic.ContainsKey("id") ? dic["id"] : "";
            AndonRecords andonRecords = await _db.Queryable<AndonRecords>().SingleAsync(x => x.id == id);
            if (andonRecords != null)
            {
                if (andonRecords.status != DictConst.AndonStatusYXY)
                {
                    throw Oops.Bah($"状态错误");  
                }
                else
                {
                    await _db.Updateable<AndonRecords>()
                        .SetColumns(x=>x.start_repair_time==DateTime.Now)
                        .Where(x=>x.id==id)
                        .ExecuteCommandAsync();
                    return true;
                }
                
            }
            else
            {
                throw Oops.Bah($"无该andon记录");  
            }
        }

        [HttpPost]
        public async Task<dynamic> EndAndon(Dictionary<string, string> dic)
        {
            string id = dic.ContainsKey("id") ? dic["id"] : "";
            AndonRecords andonRecords = await _db.Queryable<AndonRecords>().SingleAsync(x => x.id == id);
            if (andonRecords != null)
            {
                if (andonRecords.status != DictConst.AndonStatusCLZ)
                {
                    throw Oops.Bah($"状态错误");  
                }
                else
                {
                    await _db.Updateable<AndonRecords>()
                        .SetColumns(x=>x.end_repair_time==DateTime.Now)
                        .Where(x=>x.id==id)
                        .ExecuteCommandAsync();
                    return true;
                }
                
            }
            else
            {
                throw Oops.Bah($"无该andon记录");  
            }
        }
        
        [HttpPost]
        public async Task<dynamic> ConfirmAndon(Dictionary<string, string> dic)
        {
            string id = dic.ContainsKey("id") ? dic["id"] : "";
            AndonRecords andonRecords = await _db.Queryable<AndonRecords>().SingleAsync(x => x.id == id);
            if (andonRecords != null)
            {
                if (andonRecords.status != DictConst.AndonStatusYWC)
                {
                    throw Oops.Bah($"状态错误");  
                }
                else
                {
                    await _db.Updateable<AndonRecords>()
                        .SetColumns(x=>x.confirm_time==DateTime.Now)
                        .Where(x=>x.id==id)
                        .ExecuteCommandAsync();
                    return true;
                }
                
            }
            else
            {
                throw Oops.Bah($"无该andon记录");  
            }
        }

        private async Task<List<MessageSendModel>> GetSendParamJson(string id)
        {
            var list = await _db.Queryable<MessageSendTemplateEntity, MessageTemplateEntity>((a, b) => new JoinQueryInfos(JoinType.Left, a.TemplateId == b.Id))
                .Where((a, b) => a.SendConfigId == id && a.DeleteMark == null && b.DeleteMark == null)
                .Select((a, b) => new MessageSendModel
                {
                    accountConfigId = a.AccountConfigId,
                    id = a.Id,
                    messageType = SqlFunc.Subqueryable<MessageDataTypeEntity>().Where(u => u.Type == "1" && u.EnCode == a.MessageType).Select(u => u.FullName),
                    msgTemplateName = b.FullName,
                    sendConfigId = a.SendConfigId,
                    templateId = a.TemplateId,
                }).ToListAsync();
            foreach (var item in list)
            {
                // 是否存在参数.
                var flag = await _db.Queryable<MessageSmsFieldEntity>().AnyAsync(x => x.TemplateId == item.templateId && x.DeleteMark == null);
                if (flag)
                {
                    item.paramJson = await _db.Queryable<MessageTemplateParamEntity, MessageTemplateEntity, MessageSmsFieldEntity>((a, b, c) => new JoinQueryInfos(JoinType.Left, a.TemplateId == b.Id, JoinType.Left, a.TemplateId == c.TemplateId))
                    .Where((a, b, c) => a.TemplateId == item.templateId && a.DeleteMark == null && b.DeleteMark == null && a.Field == c.Field && a.Field != "@flowLink")
                    .Select((a, b) => new MessageSendParam
                    {
                        field = a.Field,
                        fieldName = a.FieldName,
                        id = a.Id,
                        templateCode = b.TemplateCode,
                        templateId = a.TemplateId,
                        templateName = b.FullName,
                        templateType = b.TemplateType
                    }).ToListAsync();
                }
                else
                {
                    item.paramJson = await _db.Queryable<MessageTemplateParamEntity, MessageTemplateEntity>((a, b) => new JoinQueryInfos(JoinType.Left, a.TemplateId == b.Id))
                    .Where((a, b) => a.TemplateId == item.templateId && a.DeleteMark == null && b.DeleteMark == null && a.Field != "@flowLink")
                    .Where((a, b) => b.Title.Contains(a.Field) || b.Content.Contains(a.Field))
                    .Select((a, b) => new MessageSendParam
                    {
                        field = a.Field,
                        fieldName = a.FieldName,
                        id = a.Id,
                        templateCode = b.TemplateCode,
                        templateId = a.TemplateId,
                        templateName = b.FullName,
                        templateType = b.TemplateType
                    }).ToListAsync();
                }
            }
            return list;
        }
    }
}