using DS.Module.Core;
using DS.Module.Core.Data;
using DS.Module.Core.Extensions;
using DS.WMS.Core.Code.Entity;
using DS.WMS.Core.Info.Entity;
using DS.WMS.Core.Op.Entity;
using DS.WMS.Core.Sys.Entity;
using DS.WMS.Core.Sys.Interface;

namespace DS.WMS.Core.Sys.Method
{
    /// <summary>
    /// 放舱通道配置
    /// </summary>
    public class ReleaseTypeService : ServiceBase, IReleaseTypeService
    {
        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="provider"></param>
        public ReleaseTypeService(IServiceProvider provider) : base(provider)
        {
            TenantDb.QueryFilter.Clear<IOrgId>();
        }

        /// <summary>
        /// 列表
        /// </summary>
        /// <param name="request"></param>
        /// <param name="isAdmin"></param>
        /// <returns></returns>
        public async Task<DataResult<List<SysReleaseType>>> GetListAsync(PageRequest request, bool isAdmin = false)
        {
            var whereList = request.GetConditionalModels(Db);
            var tenantId = long.Parse(User.TenantId);
            var data = await Db.Queryable<SysReleaseType>()
                .Where(whereList).WhereIF(!isAdmin, x => x.TenantId == tenantId)
                .ToQueryPageAsync(request.PageCondition);

            if (!isAdmin && data.Data?.Count > 0)
            {
                var ids = data.Data.Where(x => x.CustomerId.HasValue).Select(x => x.CustomerId.Value);
                var list = await TenantDb.Queryable<InfoClient>().Where(x => ids.Contains(x.Id)).Select(x => new { x.Id, x.ShortName }).ToListAsync();
                foreach (var item in data.Data)
                    item.CustomerName = list.Find(x => x.Id == item.CustomerId)?.ShortName;
            }

            return data;
        }

        /// <summary>
        /// 根据业务数据匹配放舱方式
        /// </summary>
        /// <param name="businessId">业务ID</param>
        /// <param name="businessType">业务类型</param>
        /// <returns></returns>
        public async Task<SpaceReleaseType?> GetReleaseTypeAsync(long businessId, BusinessType businessType)
        {
            SpaceReleaseType? releaseType = null;
            switch (businessType)
            {
                case BusinessType.OceanShippingExport:
                    var order1 = await TenantDb.Queryable<SeaExport>().Where(x => x.Id == businessId)
                        .LeftJoin<CodeCarrier>((x, y) => x.CarrierId == y.Id)
                        .Select((x, y) => new
                        {
                            x.CustomerId,
                            x.LoadPortCode,
                            CarrierCode = y.Code
                        }).FirstAsync();
                    if (order1 == null)
                        return null;

                    long tid = long.Parse(User.TenantId);
                    var list = await Db.Queryable<SysReleaseType>().Where(x => x.TenantId == tid && x.CustomerId == order1.CustomerId && x.LoadingPort == order1.LoadPortCode)
                        .Select(x => new { x.Carrier, x.ReleaseType }).ToListAsync();
                    var clientItem = list.Find(x => x.Carrier == order1.CarrierCode);
                    if (clientItem != null)
                        return clientItem.ReleaseType;

                    if (list.Count > 0) //返回默认船公司的配置
                        return list[0].ReleaseType;

                    //租户端无匹配的设置，需要从管理端获取全局参数
                    var list2 = await Db.Queryable<SysReleaseType>().Where(x => x.TenantId == null && x.LoadingPort == order1.LoadPortCode)
                        .Select(x => new { x.Carrier, x.ReleaseType }).ToListAsync();
                    var adminItem = list2.Find(x => x.Carrier == order1.CarrierCode);
                    if (adminItem != null)
                        return adminItem.ReleaseType;

                    if (list2.Count > 0)
                        return list[0].ReleaseType;

                    break;

                case BusinessType.OceanShippingImport:
                    break;
            }

            return releaseType;
        }

        /// <summary>
        /// 详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<DataResult<SysReleaseType>> GetAsync(long id)
        {
            var data = await Db.Queryable<SysReleaseType>().Where(x => x.Id == id).FirstAsync();
            return DataResult<SysReleaseType>.Success(data);
        }

        /// <summary>
        /// 编辑
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<DataResult> EditAsync(SysReleaseType entity)
        {
            int rows = 0;
            if (entity.Id == 0)
            {
                rows = await Db.Insertable(entity).ExecuteCommandAsync();
            }
            else
            {
                rows = await Db.Updateable(entity).UpdateColumns(x => new
                {
                    x.CustomerId,
                    x.Carrier,
                    x.LoadingPort,
                    x.ReleaseType
                }).ExecuteCommandAsync();
            }

            return rows > 0 ? DataResult.Success : DataResult.FailedWithDesc(MultiLanguageConst.Operation_Failed);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public async Task<DataResult> DeleteAsync(params long[] ids)
        {
            int rows = await Db.Deleteable<SysReleaseType>().Where(x => ids.Contains(x.Id)).ExecuteCommandAsync();
            return rows > 0 ? DataResult.Success : DataResult.FailedWithDesc(MultiLanguageConst.Operation_Failed);
        }
    }
}