using DS.Module.Core;
using DS.Module.RedisModule;
using DS.Module.SqlSugar;
using DS.Module.UserModule;
using DS.WMS.Core.Code.Interface;
using DS.WMS.Core.Code.Method;
using DS.WMS.Core.Map.Interface;
using DS.WMS.Core.Map.Method;
using DS.WMS.Core.Sys.Interface;
using DS.WMS.Core.Sys.Method;
using DS.WMS.Core.TaskPlat.Dtos;
using DS.WMS.Core.TaskPlat.Entity;
using DS.WMS.Core.TaskPlat.Interface;
using Microsoft.Extensions.DependencyInjection;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Mapster;
using DS.Module.DjyServiceStatus;
using Microsoft.AspNetCore.Identity;
using DS.WMS.Core.Op.Interface;
using Masuit.Tools;
using DS.WMS.Core.Op.Dtos;
using DS.WMS.Core.Sys.Entity;
using HtmlAgilityPack;
using Microsoft.AspNetCore.Mvc;
using Amazon.Runtime.Internal.Util;
using Newtonsoft.Json;
using NLog;
using DS.Module.Core.Helpers;
using System.Text.Json.Nodes;
using LanguageExt.Pipes;
using DS.WMS.Core.Op.Entity;
using Org.BouncyCastle.Asn1.X9;
using DS.WMS.Core.Op.EDI;
using DS.WMS.Core.Sys.Dtos;
using DS.WMS.Core.Code.Dtos;
using DS.Module.Core.Data;
using LanguageExt.Common;
using DS.WMS.Core.Op.Method.TaskInteraction;
using DS.WMS.Core.Op.Entity.TaskInteraction;

namespace DS.WMS.Core.TaskPlat.Method
{
    public class TaskPOLContainerNotPickUpService : TaskManageBaseService<TaskPOLContainerNotPickUpService>, ITaskPOLContainerNotPickUpService
    {
        private readonly ISeaExportService _seaExportService;
        private readonly IConfigService _configService;
        private readonly IUserService _userService;
        private readonly ITaskLogService _logService;
        private readonly ITaskMailService _taskMailService;

        public TaskPOLContainerNotPickUpService(IUser user,
                                                 ILogger<TaskPOLContainerNotPickUpService> logger,
                                                 ISaasDbService saasDbService,
                                                 IServiceProvider serviceProvider,
                                                 IWebHostEnvironment environment) : base(user, logger, saasDbService, serviceProvider, environment)
        {
            _serviceProvider = serviceProvider;
            db = _serviceProvider.GetRequiredService<ISqlSugarClient>();
            user = _serviceProvider.GetRequiredService<IUser>();
            saasService = _serviceProvider.GetRequiredService<ISaasDbService>();
            _seaExportService = _serviceProvider.GetRequiredService<ISeaExportService>();
            _configService = _serviceProvider.GetRequiredService<IConfigService>();
            _userService = _serviceProvider.GetRequiredService<IUserService>();
        }

        #region 通过任务主键获取起运港未提箱详情
        /// <summary>
        /// 通过任务主键获取起运港未提箱详情
        /// </summary>
        /// <param name="taskPKId">起运港未提箱任务主键</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult<List<TaskPOLContainerNotPickUpShowDto>>> GetInfoByTaskId(long taskPKId)
        {
            //await SetTaskStatus(11, TaskBaseTypeEnum.CUT_MODIFY, TaskStatusEnum.Create, DateTime.Now, null);
            List<TaskPOLContainerNotPickUpShowDto> list = new List<TaskPOLContainerNotPickUpShowDto>();

            var tenantDb = saasDbService.GetBizDbScopeById(user.TenantId);
            //任务不考虑OrgId,这里去掉
            tenantDb.QueryFilter.Clear<IOrgId>();

            var queryList = await tenantDb.Queryable<TaskBaseInfo>()
                .InnerJoin<TaskPolContainerNotPickup>((a, b) => a.Id == b.TASK_ID)
                .Where((a, b) => a.Id == taskPKId)
                .Select((a, b) => new { Base = a, Pol = b })
                .ToListAsync();

            //任务主键{taskPkId}无法获取业务信息
            if (queryList.Count == 0)
                throw new Exception(string.Format(MultiLanguageConst.GetDescription(nameof(MultiLanguageConst.TaskBaseInfoFromTaskIdNull)), taskPKId));

            if (queryList.Count > 0)
            {
                list = queryList.Select(a => a.Pol.Adapt<TaskPOLContainerNotPickUpShowDto>()).ToList();
            }

            return DataResult<List<TaskPOLContainerNotPickUpShowDto>>.Success(list);
        }
        #endregion

        #region 检索对应的订舱订单并保存订舱ID
        /// <summary>
        /// 检索对应的订舱订单并保存订舱ID
        /// </summary>
        /// <param name="taskPKId">起运港未提箱任务主键</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult<SeaExportOrderExtension>> SearchAndMarkBookingOrder(long taskPKId)
        {
            var tenantDb = saasDbService.GetBizDbScopeById(user.TenantId);

            

            var entity = tenantDb.Queryable<TaskPolContainerNotPickup>().Filter(null, true).First(a => a.TASK_ID == taskPKId);

            return await _seaExportService.SearchOrderInfo(entity.MBL_NO);
        }
        #endregion

        #region 发送邮件通知给客户
        /// <summary>
        /// 发送邮件通知给客户
        /// </summary>
        /// <param name="taskPKId">起运港未提箱主键</param>
        /// <param name="businessTaskMailId">邮件模板主键</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult> InnerSendEmailToCustomer(long taskPKId, long businessTaskMailId)
        {
            //先匹配订单记录（这里可能关联的是拆票或者合票订单，如果是拆票需要所有拆票记录都要发邮件通知）
            var searchInfo = SearchAndMarkBookingOrder(taskPKId).GetAwaiter().GetResult().Data;

            BusinessTaskMail? mailConfig = _taskMailService.GetAsync(businessTaskMailId).GetAwaiter().GetResult().Data;

            if (mailConfig == null)
            {
                await _logService.WriteLogAsync(new Op.Dtos.TaskInteraction.TaskUpdateRequest
                {
                    BusinessId = taskPKId,
                    BusinessType = BusinessType.OceanShippingExport,
                    AutoCreateNext = true,
                    TaskTypeName = TaskBaseTypeEnum.POL_CTN_NOT_PICKUP.GetDescription(),

                }, $"未能根据任务配置值获取邮件模板设置");

                return DataResult.Failed("未能根据任务配置值获取邮件模板设置");
            }

            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

            var entity = tenantDb.Queryable<TaskPolContainerNotPickup>().Filter(null, true).First(a => a.TASK_ID == taskPKId);

            var orderInfo = _seaExportService.SearchOrderInfo(entity.MBL_NO).GetAwaiter().GetResult().Data;

            var taskInfo = entity.Adapt<TaskPOLContainerNotPickUpShowDto>();

            var model = new MailTemplateModel<TaskPOLContainerNotPickUpShowDto>(taskInfo)
            {
                BusinessId = orderInfo.currOrder.Id,
                BusinessType = BusinessType.OceanShippingExport,
            };

            MailService mailService = new MailService(_serviceProvider);
            var result = await mailService.SendAsync(mailConfig, model);

            if (!result.Succeeded)
            {
                await _logService.WriteLogAsync(new Op.Dtos.TaskInteraction.TaskUpdateRequest
                {
                    BusinessId = taskPKId,
                    BusinessType = BusinessType.OceanShippingExport,
                    AutoCreateNext = true,
                    TaskTypeName = TaskBaseTypeEnum.POL_CTN_NOT_PICKUP.GetDescription(),

                }, result.Message);

                return DataResult.Failed(result.Message);
            }

            //await SetTaskCompleteAsync(context.TaskInfo,
            //    context.ServiceProvider.GetRequiredService<ITaskService>(), LogService);

            return DataResult.Successed(result.Message);
        }
        #endregion

        #region 发送邮件通知给客户(任务自动机调取)
        /// <summary>
        /// 发送邮件通知给客户(任务自动机调取)
        /// </summary>
        /// <param name="dataContext">数据上下文</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult> SendEmailToCustomerTask(TaskFlowDataContext dataContext)
        {
            var taskPKId = dataContext.Get<Nullable<long>>(TaskFlowDataNameConst.TaskPKId) ?? throw new ArgumentException($"缺少参数:{nameof(TaskFlowDataNameConst.TaskPKId)}");
            var businessTaskMailId = dataContext.Get<Nullable<long>>($"{nameof(BusinessTaskMail)}.{nameof(BusinessTaskMail.Id)}") ?? throw new ArgumentException();

            if (businessTaskMailId == 0)
            {
                await _logService.WriteLogAsync(new Op.Dtos.TaskInteraction.TaskUpdateRequest { 
                    BusinessId = taskPKId,
                    BusinessType = BusinessType.OceanShippingExport,
                    AutoCreateNext = true,
                    TaskTypeName = TaskBaseTypeEnum.POL_CTN_NOT_PICKUP.GetDescription(),
                    
                }, $"缺少参数:{nameof(BusinessTaskMail)}.{nameof(BusinessTaskMail.Id)}");
                
                return DataResult.Failed($"缺少参数:{nameof(BusinessTaskMail)}.{nameof(BusinessTaskMail.Id)}");
            }

            return await InnerSendEmailToCustomer(taskPKId, businessTaskMailId);
        }
        #endregion

        #region 手工发送邮件通知给客户
        /// <summary>
        /// 手工发送邮件通知给客户
        /// </summary>
        /// <param name="taskPKId">起运港未提箱任务主键</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult> ManualSendEmailToCustomer(long taskPKId)
        {
            var paramConfig = _configService.GetConfig("POLContainerNotPickUpEmailTemplateID", long.Parse(user.TenantId), false).GetAwaiter().GetResult()?.Data?.Value;

            long businessTaskMailId = 0;

            if (!string.IsNullOrWhiteSpace(paramConfig))
            {
                businessTaskMailId = long.Parse(paramConfig);
            }
            else
            {
                return DataResult.Failed($"缺少系统参数参数:起运港未提箱邮件模板ID-POLContainerNotPickUpEmailTemplateID");
            }

            return await InnerSendEmailToCustomer(taskPKId, businessTaskMailId);
        }
        #endregion
    }
}