using System.Linq.Expressions;
using System;
using AutoMapper;
using Win_in.Sfs.Shared.Domain;
using Volo.Abp.AutoMapper;

namespace Win_in.Sfs.Shared.Application;

/// <summary>
///
/// </summary>
public static class CommonMapperExtensions
{
    /// <summary>
    ///
    /// </summary>
    /// <param name="m"></param>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TDestination"></typeparam>
    /// <returns></returns>
    public static IMappingExpression<TSource, TDestination> MapNegativeQty<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasQty
        where TDestination : IHasQty
    {
        return m.ForMember(dest => dest.Qty, opts => opts.MapFrom(src => -src.Qty))
            ;
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="m"></param>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TDestination"></typeparam>
    /// <returns></returns>
    public static IMappingExpression<TSource, TDestination> MapRecommendNormal<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLot, IHasQty, IHasPacking, IHasContainer
        where TDestination : IHasRecommend
    {
        return m
                .ForMember(x => x.RecommendLot, y => y.MapFrom(d => d.Lot))
                .ForMember(x => x.RecommendSupplierBatch, y => y.MapFrom(d => d.SupplierBatch))
                .ForMember(x => x.RecommendArriveDate, y => y.MapFrom(d => d.ArriveDate))
                .ForMember(x => x.RecommendProduceDate, y => y.MapFrom(d => d.ProduceDate))
                .ForMember(x => x.RecommendExpireDate, y => y.MapFrom(d => d.ExpireDate))
                .ForMember(x => x.Uom, y => y.MapFrom(d => d.Uom))
                .ForMember(x => x.RecommendQty, y => y.MapFrom(d => d.Qty))
                .ForMember(x => x.RecommendContainerCode, y => y.MapFrom(d => d.ContainerCode))
                .ForMember(x => x.RecommendPackingCode, y => y.MapFrom(d => d.PackingCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapRecommendFromNormal<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLot, IHasQty, IHasPacking, IHasContainer
        where TDestination : IHasRecommendFrom
    {
        return m
                .ForMember(x => x.RecommendLot, y => y.MapFrom(d => d.Lot))
                .ForMember(x => x.RecommendSupplierBatch, y => y.MapFrom(d => d.SupplierBatch))
                .ForMember(x => x.RecommendArriveDate, y => y.MapFrom(d => d.ArriveDate))
                .ForMember(x => x.RecommendProduceDate, y => y.MapFrom(d => d.ProduceDate))
                .ForMember(x => x.RecommendExpireDate, y => y.MapFrom(d => d.ExpireDate))
                .ForMember(x => x.Uom, y => y.MapFrom(d => d.Uom))
                .ForMember(x => x.RecommendQty, y => y.MapFrom(d => d.Qty))
                .ForMember(x => x.RecommendContainerCode, y => y.MapFrom(d => d.ContainerCode))
                .ForMember(x => x.RecommendPackingCode, y => y.MapFrom(d => d.PackingCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapRecommendToNormal<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLot, IHasQty, IHasPacking, IHasContainer
        where TDestination : IHasRecommendTo
    {
        return m
                .ForMember(x => x.RecommendLot, y => y.MapFrom(d => d.Lot))
                .ForMember(x => x.RecommendSupplierBatch, y => y.MapFrom(d => d.SupplierBatch))
                .ForMember(x => x.RecommendArriveDate, y => y.MapFrom(d => d.ArriveDate))
                .ForMember(x => x.RecommendProduceDate, y => y.MapFrom(d => d.ProduceDate))
                .ForMember(x => x.RecommendExpireDate, y => y.MapFrom(d => d.ExpireDate))
                .ForMember(x => x.Uom, y => y.MapFrom(d => d.Uom))
                .ForMember(x => x.RecommendQty, y => y.MapFrom(d => d.Qty))
                .ForMember(x => x.RecommendContainerCode, y => y.MapFrom(d => d.ContainerCode))
                .ForMember(x => x.RecommendPackingCode, y => y.MapFrom(d => d.PackingCode))
            ;
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="m"></param>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TDestination"></typeparam>
    /// <returns></returns>
    public static IMappingExpression<TSource, TDestination> MapRecommendLocation<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLocation
        where TDestination : IHasRecommend
    {
        return m
                .ForMember(x => x.RecommendLocationCode, y => y.MapFrom(d => d.LocationCode))
                .ForMember(x => x.RecommendLocationArea, y => y.MapFrom(d => d.LocationArea))
                .ForMember(x => x.RecommendLocationGroup, y => y.MapFrom(d => d.LocationGroup))
                .ForMember(x => x.RecommendLocationErpCode, y => y.MapFrom(d => d.LocationErpCode))
                .ForMember(x => x.RecommendWarehouseCode, y => y.MapFrom(d => d.WarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapRecommendFromLocation<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLocation
        where TDestination : IHasRecommendFrom
    {
        return m
                .ForMember(x => x.RecommendFromLocationCode, y => y.MapFrom(d => d.LocationCode))
                .ForMember(x => x.RecommendFromLocationArea, y => y.MapFrom(d => d.LocationArea))
                .ForMember(x => x.RecommendFromLocationGroup, y => y.MapFrom(d => d.LocationGroup))
                .ForMember(x => x.RecommendFromLocationErpCode, y => y.MapFrom(d => d.LocationErpCode))
                .ForMember(x => x.RecommendFromWarehouseCode, y => y.MapFrom(d => d.WarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapRecommendToLocation<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasLocation
        where TDestination : IHasRecommendTo
    {
        return m
                .ForMember(x => x.RecommendToLocationCode, y => y.MapFrom(d => d.LocationCode))
                .ForMember(x => x.RecommendToLocationArea, y => y.MapFrom(d => d.LocationArea))
                .ForMember(x => x.RecommendToLocationGroup, y => y.MapFrom(d => d.LocationGroup))
                .ForMember(x => x.RecommendToLocationErpCode, y => y.MapFrom(d => d.LocationErpCode))
                .ForMember(x => x.RecommendToWarehouseCode, y => y.MapFrom(d => d.WarehouseCode))
            ;
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="m"></param>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TDestination"></typeparam>
    /// <returns></returns>
    public static IMappingExpression<TSource, TDestination> MapNormalFromHandled<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasHandled
        where TDestination : IHasPacking, IHasContainer, IHasLot, IHasQty, IHasLocation, IHasBatch
    {
        return m
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.HandledPackingCode))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.HandledSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.HandledArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.HandledProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.HandledExpireDate))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.HandledLot))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.HandledContainerCode))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.HandledQty))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.HandledLocationErpCode))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.HandledLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.HandledLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.HandledLocationGroup))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.HandledWarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapNormalFromHandledFrom<TSource, TDestination>(
       this IMappingExpression<TSource, TDestination> m)
       where TSource : IHasHandledFrom
       where TDestination : IHasPacking, IHasContainer, IHasLot, IHasQty, IHasLocation, IHasBatch
    {
        return m
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.HandledPackingCode))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.HandledSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.HandledArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.HandledProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.HandledExpireDate))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.HandledLot))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.HandledContainerCode))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.HandledQty))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.HandledFromLocationErpCode))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.HandledFromLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.HandledFromLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.HandledFromLocationGroup))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.HandledFromWarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapNormalFromHandledTo<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasHandledTo
        where TDestination : IHasPacking, IHasContainer, IHasLot, IHasQty, IHasLocation, IHasBatch
    {
        return m
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.HandledPackingCode))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.HandledSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.HandledArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.HandledProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.HandledExpireDate))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.HandledLot))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.HandledContainerCode))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.HandledQty))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.HandledToLocationErpCode))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.HandledToLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.HandledToLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.HandledToLocationGroup))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.HandledToWarehouseCode))
            ;
    }

    /// <summary>
    ///
    /// </summary>
    /// <param name="m"></param>
    /// <typeparam name="TSource"></typeparam>
    /// <typeparam name="TDestination"></typeparam>
    /// <returns></returns>
    public static IMappingExpression<TSource, TDestination> MapExpectInOut<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasNumber, IHasItem, IHasRecommend
        where TDestination : IHasJobNumber, IHasPacking, IHasLot, IHasItem, IHasQty, IHasLocation
    {
        return m
                .ForMember(x => x.JobNumber, y => y.MapFrom(d => d.Number))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.RecommendContainerCode))
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.RecommendPackingCode))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.RecommendLot))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.RecommendSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.RecommendArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.RecommendProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.RecommendExpireDate))
                .ForMember(x => x.ItemName, y => y.MapFrom(d => d.ItemName))
                .ForMember(x => x.ItemDesc1, y => y.MapFrom(d => d.ItemDesc1))
                .ForMember(x => x.ItemDesc2, y => y.MapFrom(d => d.ItemDesc2))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.RecommendQty))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.RecommendLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.RecommendLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.RecommendLocationGroup))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.RecommendLocationErpCode))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.RecommendWarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapExpectInOutFrom<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasNumber, IHasItem, IHasRecommendFrom
        where TDestination : IHasJobNumber, IHasPacking, IHasLot, IHasItem, IHasQty, IHasLocation
    {
        return m
                .ForMember(x => x.JobNumber, y => y.MapFrom(d => d.Number))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.RecommendContainerCode))
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.RecommendPackingCode))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.RecommendLot))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.RecommendSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.RecommendArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.RecommendProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.RecommendExpireDate))
                .ForMember(x => x.ItemName, y => y.MapFrom(d => d.ItemName))
                .ForMember(x => x.ItemDesc1, y => y.MapFrom(d => d.ItemDesc1))
                .ForMember(x => x.ItemDesc2, y => y.MapFrom(d => d.ItemDesc2))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.RecommendQty))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.RecommendFromLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.RecommendFromLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.RecommendFromLocationGroup))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.RecommendFromLocationErpCode))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.RecommendFromWarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapExpectInOutTo<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasNumber, IHasItem, IHasRecommendTo
        where TDestination : IHasJobNumber, IHasPacking, IHasLot, IHasItem, IHasQty, IHasLocation
    {
        return m
                .ForMember(x => x.JobNumber, y => y.MapFrom(d => d.Number))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.RecommendContainerCode))
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.RecommendPackingCode))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.RecommendLot))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.RecommendSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.RecommendArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.RecommendProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.RecommendExpireDate))
                .ForMember(x => x.ItemName, y => y.MapFrom(d => d.ItemName))
                .ForMember(x => x.ItemDesc1, y => y.MapFrom(d => d.ItemDesc1))
                .ForMember(x => x.ItemDesc2, y => y.MapFrom(d => d.ItemDesc2))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.RecommendQty))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.RecommendToLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.RecommendToLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.RecommendToLocationGroup))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.RecommendToLocationErpCode))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.RecommendToWarehouseCode))
            ;
    }

    public static IMappingExpression<TSource, TDestination> MapIgnoreIHasRecommendAndHandledFrom<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> m)
        where TSource : IHasNumber, IHasItem, IHasRecommendFrom
        where TDestination : IHasJobNumber, IHasPacking, IHasLot, IHasItem, IHasQty, IHasLocation
    {
        return m
                .ForMember(x => x.JobNumber, y => y.MapFrom(d => d.Number))
                .ForMember(x => x.ContainerCode, y => y.MapFrom(d => d.RecommendContainerCode))
                .ForMember(x => x.PackingCode, y => y.MapFrom(d => d.RecommendPackingCode))
                .ForMember(x => x.Lot, y => y.MapFrom(d => d.RecommendLot))
                .ForMember(x => x.SupplierBatch, y => y.MapFrom(d => d.RecommendSupplierBatch))
                .ForMember(x => x.ArriveDate, y => y.MapFrom(d => d.RecommendArriveDate))
                .ForMember(x => x.ProduceDate, y => y.MapFrom(d => d.RecommendProduceDate))
                .ForMember(x => x.ExpireDate, y => y.MapFrom(d => d.RecommendExpireDate))
                .ForMember(x => x.ItemName, y => y.MapFrom(d => d.ItemName))
                .ForMember(x => x.ItemDesc1, y => y.MapFrom(d => d.ItemDesc1))
                .ForMember(x => x.ItemDesc2, y => y.MapFrom(d => d.ItemDesc2))
                .ForMember(x => x.Qty, y => y.MapFrom(d => d.RecommendQty))
                .ForMember(x => x.LocationCode, y => y.MapFrom(d => d.RecommendFromLocationCode))
                .ForMember(x => x.LocationArea, y => y.MapFrom(d => d.RecommendFromLocationArea))
                .ForMember(x => x.LocationGroup, y => y.MapFrom(d => d.RecommendFromLocationGroup))
                .ForMember(x => x.LocationErpCode, y => y.MapFrom(d => d.RecommendFromLocationErpCode))
                .ForMember(x => x.WarehouseCode, y => y.MapFrom(d => d.RecommendFromWarehouseCode))
            ;
    }

    public static IMappingExpression<TDestination, TMember> IgnoreIHasRecommendAndHandledFrom<TDestination, TMember>(this IMappingExpression<TDestination, TMember> mappingExpression)
        where TMember : IHasRecommendAndHandledFrom
    {
        return mappingExpression.Ignore(x => x.RecommendContainerCode)
            .Ignore(x => x.RecommendPackingCode)
            .Ignore(x => x.RecommendSupplierBatch)
            .Ignore(x => x.RecommendArriveDate)
            .Ignore(x => x.RecommendProduceDate)
            .Ignore(x => x.RecommendExpireDate)
            .Ignore(x => x.RecommendLot)
            .Ignore(x => x.RecommendFromLocationCode)
            .Ignore(x => x.RecommendFromLocationArea)
            .Ignore(x => x.RecommendFromLocationGroup)
            .Ignore(x => x.RecommendFromLocationErpCode)
            .Ignore(x => x.RecommendFromWarehouseCode)
            .Ignore(x => x.RecommendQty)

            .Ignore(t => t.HandledContainerCode)
            .Ignore(x => x.HandledPackingCode)
            .Ignore(x => x.HandledSupplierBatch)
            .Ignore(x => x.HandledArriveDate)
            .Ignore(x => x.HandledProduceDate)
            .Ignore(x => x.HandledExpireDate)
            .Ignore(x => x.HandledLot)
            .Ignore(x => x.HandledFromLocationCode)
            .Ignore(x => x.HandledFromLocationArea)
            .Ignore(x => x.HandledFromLocationGroup)
            .Ignore(x => x.HandledFromLocationErpCode)
            .Ignore(x => x.HandledFromWarehouseCode)
            .Ignore(x => x.HandledQty);
    }

    public static IMappingExpression<TDestination, TMember> IgnoreIHasRecommendAndHandledTo<TDestination, TMember>(this IMappingExpression<TDestination, TMember> mappingExpression)
        where TMember : IHasRecommendAndHandledTo
    {
        return mappingExpression.Ignore(x => x.RecommendContainerCode)
            .Ignore(x => x.RecommendPackingCode)
            .Ignore(x => x.RecommendSupplierBatch)
            .Ignore(x => x.RecommendArriveDate)
            .Ignore(x => x.RecommendProduceDate)
            .Ignore(x => x.RecommendExpireDate)
            .Ignore(x => x.RecommendLot)
            .Ignore(x => x.RecommendToLocationCode)
            .Ignore(x => x.RecommendToLocationArea)
            .Ignore(x => x.RecommendToLocationGroup)
            .Ignore(x => x.RecommendToLocationErpCode)
            .Ignore(x => x.RecommendToWarehouseCode)
            .Ignore(x => x.RecommendQty)

            .Ignore(t => t.HandledContainerCode)
            .Ignore(x => x.HandledPackingCode)
            .Ignore(x => x.HandledSupplierBatch)
            .Ignore(x => x.HandledArriveDate)
            .Ignore(x => x.HandledProduceDate)
            .Ignore(x => x.HandledExpireDate)
            .Ignore(x => x.HandledLot)
            .Ignore(x => x.HandledToLocationCode)
            .Ignore(x => x.HandledToLocationArea)
            .Ignore(x => x.HandledToLocationGroup)
            .Ignore(x => x.HandledToLocationErpCode)
            .Ignore(x => x.HandledToWarehouseCode)
            .Ignore(x => x.HandledQty);
    }
}