using DS.Module.Core;
using DS.Module.SqlSugar;
using DS.Module.UserModule;
using DS.WMS.Core.Op.Dtos;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Op.Interface;
using Mapster;
using Microsoft.Extensions.DependencyInjection;
using NLog;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DS.Module.Core.Extensions;
using Microsoft.Owin.Security.Provider;
using Microsoft.AspNetCore.Identity;
using DS.WMS.Core.Sys.Interface;
using DS.WMS.Core.Map.Dtos;

namespace DS.WMS.Core.Op.Method
{
    public class BookingContractNoManageService: IBookingContractNoManageService
    {
        private readonly IServiceProvider _serviceProvider;
        private readonly ISqlSugarClient db;
        private readonly IUser user;
        private readonly ISaasDbService saasService;
        private readonly ISysCacheService _sysCacheService;

        private static readonly NLog.Logger Logger = LogManager.GetCurrentClassLogger();

        //船公司基础映射模块
        const string CONST_MAPPING_CARRIER_MODULE = "CarrierBaseMapping";

        public BookingContractNoManageService(IServiceProvider serviceProvider)
        {
            _serviceProvider = serviceProvider;
            db = _serviceProvider.GetRequiredService<ISqlSugarClient>();
            user = _serviceProvider.GetRequiredService<IUser>();
            saasService = _serviceProvider.GetRequiredService<ISaasDbService>();
            _sysCacheService = _serviceProvider.GetRequiredService<ISysCacheService>();
        }

        #region 保存
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="model">合约号详情</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult<long>> Save(BookingContractNoManageDto model)
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

            BookingContractNoManage info = null;

            try
            {
                List<MappingCarrierRes> mapCarrierList = new List<MappingCarrierRes>();

                var cacheRlt = _sysCacheService.GetAllCommonCodeFromCache<MappingCarrierRes>(Sys.Method.SysCacheKeyEnum.CommonMappingCarrier)
                    .GetAwaiter().GetResult();

                if(cacheRlt.Succeeded)
                {
                    mapCarrierList = cacheRlt.Data;

                    if (model.CarrierId.HasValue && model.CarrierId.Value > 0)
                    {
                        var mapInfo = mapCarrierList.FirstOrDefault(a => a.Module == CONST_MAPPING_CARRIER_MODULE && a.LinkId == model.CarrierId.Value);

                        if (mapInfo != null)
                        {
                            model.CarrierCode = mapInfo.MapCode;
                        }
                    }
                }

                if (model.Id > 0)
                {
                    info = await tenantDb.Queryable<BookingContractNoManage>().FirstAsync(t => t.Id == model.Id);

                    //合约数据不存在或已作废
                    if (info == null)
                        throw new Exception(MultiLanguageConst.GetDescription(nameof(MultiLanguageConst.BookingContractRecordDeletedOrNoExists)));

                    info = model.Adapt<BookingContractNoManage>();

                    info.UpdateTime = DateTime.Now;
                    info.UpdateBy = long.Parse(user.UserId);

                    await tenantDb.Updateable<BookingContractNoManage>(info).IgnoreColumns(it => new
                    {
                        it.CreateTime,
                        it.CreateBy,
                        //it.CreatedUserName
                    }).ExecuteCommandAsync();
                }
                else
                {
                    info = model.Adapt<BookingContractNoManage>();

                    await tenantDb.Insertable<BookingContractNoManage>(info).ExecuteReturnEntityAsync();
                }
            }
            catch (Exception ex)
            {
                DataResult<long>.FailedData(info.Id, ex.Message);
            }

            return DataResult<long>.Success(info.Id);
        }
        #endregion

        #region 主键获取合约号详情
        /// <summary>
        /// 主键获取合约号详情
        /// </summary>
        /// <param name="Id">合约号主键</param>
        /// <returns>返回合约号详情</returns>
        public async Task<DataResult<BookingContractNoManageDto>> GetInfo(long Id)
        {
            BookingContractNoManageDto model = null;

            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            try
            {
                var info = await tenantDb.Queryable<BookingContractNoManage>().FirstAsync(t => t.Id == Id);

                //合约数据不存在或已作废
                if (info == null)
                    throw new Exception(MultiLanguageConst.GetDescription(nameof(MultiLanguageConst.BookingContractRecordDeletedOrNoExists)));


                model = info.Adapt<BookingContractNoManageDto>();

            }
            catch (Exception ex)
            {
                DataResult<BookingContractNoManageDto>.FailedData(model, ex.Message);
            }

            return DataResult<BookingContractNoManageDto>.Success(model);
        }
        #endregion

        #region 检索合约列表
        /// <summary>
        /// 检索合约列表
        /// </summary>
        /// <param name="queryItem">检索值可（模糊查询）</param>
        /// <param name="top">返回记录最大行数</param>
        /// <param name="carrier">船公司代码</param>
        /// <param name="lane">航线代码</param>
        /// <param name="lanecname">航线中文</param>
        /// <param name="pod">目的港代码</param>
        /// <returns>返回合约号详情列表</returns>
        public async Task<DataResult<List<BookingContractNoManageDto>>> QuerytContractNoInfo(string queryItem, int top = 10, string carrier = "", string lane = "", string lanecname = "", string pod = "")
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

            var query = tenantDb.Queryable<BookingContractNoManage>();

            if (!string.IsNullOrWhiteSpace(queryItem))
            {
                query = query.Where(t =>
                t.ContractNo.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractName.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractNote.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractPartyCode.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractPartyName.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractLinkName.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase) ||
                t.ContractLinkEmail.Contains(queryItem.Trim(), StringComparison.OrdinalIgnoreCase)
                );
            }

            if (!string.IsNullOrWhiteSpace(carrier))
            {
                query = query.Where(t => t.CarrierCode.Equals(carrier));
            }

            if (!string.IsNullOrWhiteSpace(lane))
            {
                query = query.Where(t => string.IsNullOrWhiteSpace(t.LaneCode) || t.LaneCode.Contains(lane));
            }

            if (!string.IsNullOrWhiteSpace(lanecname))
            {
                query = query.Where(t => string.IsNullOrWhiteSpace(t.LaneCName) || t.LaneCName.Contains(lanecname));
            }

            if (!string.IsNullOrWhiteSpace(pod))
            {
                query = query.Where(t => string.IsNullOrWhiteSpace(t.PodCode) || t.PodCode.Contains(pod));
            }

            var data = await query.Select<BookingContractNoManageDto>().OrderBy(a=>a.ContractNo).Take(top).ToListAsync();

            if(data.Count > 0)
                return DataResult<List<BookingContractNoManageDto>>.FailedData(data);

            return DataResult<List<BookingContractNoManageDto>>.Success(data);
        }
        #endregion

        #region 作废（可批量删除）
        /// <summary>
        /// 作废（可批量删除）
        /// </summary>
        /// <param name="Ids">合约号主键组</param>
        /// <returns>返回回执</returns>
        public async Task<DataResult<string>> Delete(long[] Ids)
        {
            try
            {
                var tenantDb = saasService.GetBizDbScopeById(user.TenantId);

                //没有提供需要作废的主键信息
                if (Ids.Length == 0)
                    throw new Exception(MultiLanguageConst.GetDescription(nameof(MultiLanguageConst.BookingContractDeleteIdsNull)));



                var list = tenantDb.Queryable<BookingContractNoManage>().Where(t => Ids.Contains(t.Id)).ToList();

                if (list.Count != Ids.Length)
                {
                    var noRecord = string.Join(",", Ids.GroupJoin(list, l => l, r => r.Id, (l, r) =>
                    {
                        var currList = r.ToList();

                        if (r.Count() > 0)
                            return string.Empty;

                        return l.ToString();
                    }).Where(t => !string.IsNullOrWhiteSpace(t)).ToArray());

                    throw new Exception(MultiLanguageConst.GetDescription(nameof(MultiLanguageConst.BookingContractRecordDeletedOrNoExists)));
                }

                list.ForEach(async entity =>
                {
                    entity.Deleted = true;
                    entity.DeleteTime = DateTime.Now;
                    entity.DeleteBy = long.Parse(user.UserId);
                    //entity.UpdatedUserName = UserManager.Name;

                    await tenantDb.Updateable<BookingContractNoManage>().IgnoreColumns(it => new
                    {
                        it.CreateTime,
                        it.CreateBy,
                        //it.CreatedUserName
                    }).ExecuteCommandAsync();
                });

            }
            catch (Exception ex)
            {
                //throw Oops.Bah($"作废约号参数异常，{ex.Message}");

                DataResult<string>.FailedData(string.Empty, ex.Message);
            }

            return DataResult<string>.Success(string.Empty);
        }
        #endregion

        #region 合约号管理台账
        /// <summary>
        /// 合约号管理台账
        /// </summary>
        /// <param name="QuerySearch">查询条件</param>
        /// <returns>返回台账列表</returns>
        public async Task<DataResult<List<BookingContractNoManageDto>>> GetPageAsync(PageRequest QuerySearch)
        {
            var tenantDb = saasService.GetBizDbScopeById(user.TenantId);
            //序列化查询条件
            var whereList = db.ConfigQuery.Context.Utilities.JsonToConditionalModels(QuerySearch.QueryCondition);

            var data = tenantDb.Queryable<BookingContractNoManage>()
               .Where(whereList)
               .Select<BookingContractNoManageDto>().ToQueryPage(QuerySearch.PageCondition);
            return data;
        }
        #endregion
    }
}