using AutoMapper;
using AutoMapper.QueryableExtensions;
using IRaCIS.Application.ExpressionExtend;
using IRaCIS.Application.Interfaces;
using IRaCIS.Application.ViewModels;
using IRaCIS.Core.Application.Contracts.RequestAndResponse;
using IRaCIS.Core.Domain.Share;
using System;
using System.Collections.Generic;
using System.Linq;
using IRaCIS.Core.Domain.Interfaces;
using IRaCIS.Core.Domain.Models;

namespace IRaCIS.Application.Services.Pay
{
    public class RankPriceService : IRankPriceService
    {
        private readonly IRankPriceRepository _rankPriceRepository;
        private readonly IReviewerPayInfoRepository _reviewerPayInfoRepository;
        private readonly IMapper _mapper;

        public RankPriceService(IRankPriceRepository rankPriceRepository, IReviewerPayInfoRepository reviewerPayInfoRepository,IMapper mapper)
        {
            _rankPriceRepository = rankPriceRepository;
            _reviewerPayInfoRepository = reviewerPayInfoRepository;
            _mapper = mapper;
        }


        public IResponseOutput AddOrUpdateRankPrice(RankPriceCommand addOrUpdateModel, Guid userId)
        {
            if (addOrUpdateModel.Id == Guid.Empty|| addOrUpdateModel.Id ==null)
            {
                var rankPrice = _mapper.Map<RankPrice>(addOrUpdateModel);
                rankPrice = _rankPriceRepository.Add(rankPrice);
                if (_rankPriceRepository.SaveChanges())
                {
                    return ResponseOutput.Ok(rankPrice.Id.ToString());
                }
                else
                {
                    return ResponseOutput.NotOk();
                }

            }
            else
            {
                var success = _rankPriceRepository.Update(t => t.Id == addOrUpdateModel.Id, u => new RankPrice()
                {
                    UpdateUserId = userId,
                    UpdateTime = DateTime.Now,
                    RefresherTraining=addOrUpdateModel.RefresherTraining,
                    RankName = addOrUpdateModel.RankName,
                    Timepoint = addOrUpdateModel.Timepoint,
                    TimepointIn24H = addOrUpdateModel.TimepointIn24H,
                    TimepointIn48H = addOrUpdateModel.TimepointIn48H,
                    Adjudication = addOrUpdateModel.Adjudication,
                    AdjudicationIn24H = addOrUpdateModel.AdjudicationIn24H,
                    AdjudicationIn48H = addOrUpdateModel.AdjudicationIn48H,
                    Global = addOrUpdateModel.Global,
                    Training = addOrUpdateModel.Training,
                    Downtime = addOrUpdateModel.Downtime

                });


                return ResponseOutput.Result(success, success ? "" : StaticData.UpdateFailed);
            }
        }

        public IResponseOutput DeleteRankPrice(Guid id)
        {

            if (_reviewerPayInfoRepository.GetAll().Any(t => t.RankId == id))
            {
                return ResponseOutput.NotOk("This title has been used by reviewer payment information");
            }

            var success = _rankPriceRepository.Delete(t => t.Id == id);

            return ResponseOutput.Result(success, success ? string.Empty : StaticData.DeleteFailed);
        }

        public PageOutput<RankPriceDTO> GetRankPriceList(RankPriceQueryDTO queryParam)
        {
            var rankPriceQueryable = _rankPriceRepository.GetAll().ProjectTo<RankPriceDTO>(_mapper.ConfigurationProvider);

            //var propName = string.IsNullOrWhiteSpace(queryParam.SortField) ? "RankName" : queryParam.SortField;
            //rankPriceQueryable = queryParam.Asc ? rankPriceQueryable.OrderBy(propName) : rankPriceQueryable.OrderByDescending(propName);

            rankPriceQueryable = rankPriceQueryable.OrderBy("ShowOrder");
            var count = rankPriceQueryable.Count();
            rankPriceQueryable = rankPriceQueryable.Skip((queryParam.PageIndex - 1) * queryParam.PageSize)
                .Take(queryParam.PageSize);
            var list = rankPriceQueryable.ToList();

            return new PageOutput<RankPriceDTO>(queryParam.PageIndex, queryParam.PageSize, count, list);
        }


        public List<RankDic> GetRankDic()
        {
            var rankQueryable = _rankPriceRepository.GetAll().ProjectTo<RankDic>(_mapper.ConfigurationProvider);
            return rankQueryable.ToList();

        }

    }
}