using AutoMapper;
using AutoMapper.Internal;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq.Expressions;
using YLErp.Model;
using AutoMapperExtensions = AutoMapper.QueryableExtensions.Extensions;

namespace YLErp
{
    /// <summary>
    /// 
    /// </summary>
    public static class YLAutoMapper
    {
        static readonly IMapper _mapper;

        public static readonly MapperConfiguration Config;

        static YLAutoMapper()
        {
            //这里应该只配置不同类型之间的相互映射
            //对于automapper映射配置,相同类型不需要做map，使用clone方式就可以

            Config = new MapperConfiguration(cfg =>
            {
                cfg.Internal().ForAllMaps((t, x) =>
                {
                    x.IgnoreAllPropertiesWithAnInaccessibleSetter();
                });

                MapTradeDto(cfg);

                cfg.CreateMap<volatility, volatility>().ForMember(dest => dest.id, opt => opt.Ignore());
                cfg.CreateMap<ExchangeTrade, ExchangeTradeDto>();
                cfg.CreateMap<ExchangeTradeDto, ExchangeTrade>();
                cfg.CreateMap<SalesCommissionInfo, SalesCommissionInfoDto>();
                cfg.CreateMap<eod_forward_margin, eod_forward_marginDto>();
                cfg.CreateMap<CreditIntraday, CreditIntradayDto>().IgnoreNotMapped();
                cfg.CreateMap<trade_asian_option, trade_asian_optionDto>().IgnoreNotMapped();
                cfg.CreateMap<trade_barrier_option, trade_barrier_optionDto>().IgnoreNotMapped();
                cfg.CreateMap<trade_snowball, trade_snowballDto>().IgnoreNotMapped();
                cfg.CreateMap<SysUserConfig, SysUserConfigDto>().IgnoreNotMapped();
            });

            _mapper = Config.CreateMapper();
        }

        //转为交易数据转换分出来一个配置方法
        private static void MapTradeDto(IMapperConfigurationExpression cfg)
        {
            cfg.CreateMap<trade, TradeReq>();

            //所有基于OtcTradeBase的继承类可以相互映射
            cfg.CreateMap<OtcTradeBase, OtcTradeBase>();

            //返回Extend映射到Full
            IMappingExpression<OtcOptionTradeFull, TExtend> MapFullToExtend<TExtend>() where TExtend : TradeExtendBase
            {
                return cfg.CreateMap<OtcOptionTradeFull, TExtend>()
                    .ForMember(dest => dest.id, opt => opt.Ignore())
                    .ForMember(dest => dest.TradeId, opt => opt.MapFrom(src => src.id));
            }

            //返回Extend映射到Full
            IMappingExpression<TExtend, OtcOptionTradeFull> MapExtendToFull<TExtend>() where TExtend : TradeExtendBase
            {
                return cfg.CreateMap<TExtend, OtcOptionTradeFull>()
                    .ForMember(dest => dest.id, opt => opt.Ignore())
                    .ForMember(dest => dest.OptId, opt => opt.Ignore())
                    .ForMember(dest => dest.OptName, opt => opt.Ignore())
                    .ForMember(dest => dest.OptDate, opt => opt.Ignore());
            }

            //亚式期权
            MapFullToExtend<trade_asian_option>();
            MapExtendToFull<trade_asian_option>();

            //障碍期权
            MapFullToExtend<trade_barrier_option>()
                .ForMember(dest => dest.Discrete, opt => opt.MapFrom(src => src.MonitorType))
                .ForMember(dest => dest.BarrierPrice, opt => opt.MapFrom(src => src.BarrierLow))
                .ForMember(dest => dest.UpperBarrierPrice, opt => opt.MapFrom(src => src.BarrierHigh));

            MapExtendToFull<trade_barrier_option>()
                .ForMember(dest => dest.BarrierLow, opt => opt.MapFrom(src => src.BarrierPrice))
                .ForMember(dest => dest.BarrierHigh, opt => opt.MapFrom(src => src.UpperBarrierPrice))
                .ForMember(dest => dest.MonitorType, opt => opt.MapFrom(src => src.Discrete));

            //双鲨期权
            MapFullToExtend<trade_double_sharkfin_option>()
                .ForMember(dest => dest.Discrete, opt => opt.MapFrom(src => src.MonitorType));

            MapExtendToFull<trade_double_sharkfin_option>()
                .ForMember(dest => dest.MonitorType, opt => opt.MapFrom(src => src.Discrete));

            //二元期权
            MapFullToExtend<trade_binary_option>()
               .ForMember(dest => dest.UpperBarrier, opt => opt.MapFrom(src => src.BarrierHigh));

            MapExtendToFull<trade_binary_option>()
                .ForMember(dest => dest.BarrierHigh, opt => opt.MapFrom(src => src.UpperBarrier));

            //区间累积期权
            MapFullToExtend<trade_rangeaccrual>();
            MapExtendToFull<trade_rangeaccrual>();

            //气囊结构
            MapFullToExtend<trade_airbag>()
                .ForMember(dest => dest.Barrier, opt => opt.MapFrom(src => src.BarrierLow));
            MapExtendToFull<trade_airbag>()
                .ForMember(dest => dest.BarrierLow, opt => opt.MapFrom(src => src.Barrier));

            //收益增强结构
            MapFullToExtend<trade_underlying_enhance>();
            MapExtendToFull<trade_underlying_enhance>();

            //凤凰期权
            MapFullToExtend<trade_autocall>();
            MapExtendToFull<trade_autocall>();

            //雪球期权
            MapFullToExtend<trade_snowball>()
                 .ForMember(dest => dest.SpreadStrikeAtMaturity, opt => opt.MapFrom(src => src.SpreadStrike))
                .ForMember(dest => dest.SpreadStrikeAtMaturity1, opt => opt.MapFrom(src => src.SpreadStrike1));
            MapExtendToFull<trade_snowball>()
                .ForMember(dest => dest.SpreadStrike, opt => opt.MapFrom(src => src.SpreadStrikeAtMaturity))
                .ForMember(dest => dest.SpreadStrike1, opt => opt.MapFrom(src => src.SpreadStrikeAtMaturity1));

            //累计期权
            MapFullToExtend<trade_accumulator_option>();
            MapExtendToFull<trade_accumulator_option>();

            //现金流交易
            MapFullToExtend<trade_cashflow>()
                .ForMember(dest => dest.ProfitDayCount, opt => opt.MapFrom(src => src.CouponDayCount));
            MapExtendToFull<trade_cashflow>()
                .ForMember(dest => dest.CouponDayCount, opt => opt.MapFrom(src => src.ProfitDayCount));

            //累计期权
            MapFullToExtend<trade_custom>();
            MapExtendToFull<trade_custom>();

            //累计期权
            MapFullToExtend<trade_risky_option>();
            MapExtendToFull<trade_risky_option>();

            //远期交易

            cfg.CreateMap<OtcTradeForward, trade_forward>()
                    .ForMember(dest => dest.id, opt => opt.Ignore())
                    .ForMember(dest => dest.TradeId, opt => opt.MapFrom(src => src.id));

            cfg.CreateMap<trade_forward, OtcTradeForward>()
                .ForMember(dest => dest.id, opt => opt.Ignore())
                .ForMember(dest => dest.OptId, opt => opt.Ignore())
                .ForMember(dest => dest.OptName, opt => opt.Ignore())
                .ForMember(dest => dest.OptDate, opt => opt.Ignore());
        }

        public static void Initialize()
        {
            //不需要任何代码
        }

        /// <summary>
        /// 
        /// </summary>
        public static TDestination Map<TDestination>(object source)
        {
            return _mapper.Map<TDestination>(source);
        }

        /// <summary>
        /// 从source映射字段到destination
        /// </summary>
        public static void Map<TClass>(TClass source, TClass destination)
        {
            _mapper.Map(source, destination);
        }

        /// <summary>
        /// 从source映射字段到destination
        /// </summary>
        public static void Map<TSource, TDestination>(TSource source, TDestination destination)
        {
            _mapper.Map(source, destination);
        }

        /// <summary>
        /// AutoMapper数据查询对象转换
        /// </summary>
        public static IQueryable<TDestination> ProjectTo<TDestination>(this IQueryable source, object parameters, params Expression<Func<TDestination, object>>[] membersToExpand)
        {
            return AutoMapperExtensions.ProjectTo<TDestination>(source, Config, parameters, membersToExpand);
        }

        /// <summary>
        /// AutoMapper数据查询对象转换
        /// </summary>
        public static IQueryable<TDestination> ProjectTo<TDestination>(this IQueryable source, params Expression<Func<TDestination, object>>[] membersToExpand)
        {
            return AutoMapperExtensions.ProjectTo<TDestination>(source, Config, membersToExpand);
        }

        /// <summary>
        /// AutoMapper数据查询对象转换
        /// </summary>
        public static IQueryable<TDestination> ProjectTo<TDestination>(this IQueryable source, IDictionary<string, object> parameters, params string[] membersToExpand)
        {
            return AutoMapperExtensions.ProjectTo<TDestination>(source, Config, parameters, membersToExpand);
        }

        //从实体模型映射到DTO时忽略NotMapped属性,不然调用ProjectTo从数据库取数据时报错
        public static IMappingExpression<TSource, TDestination> IgnoreNotMapped<TSource, TDestination>(
            this IMappingExpression<TSource, TDestination> expression)
        {
            var sourceType = typeof(TSource);
            foreach (var property in sourceType.GetProperties())
            {
                var descriptor = TypeDescriptor.GetProperties(sourceType)[property.Name];
                var attribute = (NotMappedAttribute)descriptor.Attributes[typeof(NotMappedAttribute)];
                if (attribute != null)
                {
                    expression.ForMember(property.Name, opt => opt.Ignore());
                }
            }
            return expression;
        }
    }
}