package com.careem.incentives.ms.promotion.interfaces.controller.rest;

import static com.careem.lib.commons.type.ResponseCodeType.VALID_REQUEST_BUT_OP_FAILED;
import static org.springframework.web.bind.annotation.RequestMethod.GET;
import static org.springframework.web.bind.annotation.RequestMethod.PATCH;
import static org.springframework.web.bind.annotation.RequestMethod.POST;

import com.careem.commons.sdk.ms.interfaces.controller.interceptor.builder.CareemErrorResponse;
import com.careem.incentives.ms.promotion.domain.promo.models.PromoCodeLookup;
import com.careem.incentives.ms.promotion.domain.promo.models.Promotion;
import com.careem.incentives.ms.promotion.domain.promo.models.PromotionBriefInfo;
import com.careem.incentives.ms.promotion.domain.promo.repos.PromotionAttributesRepo;
import com.careem.incentives.ms.promotion.domain.promo.repos.PromotionRepo;
import com.careem.incentives.ms.promotion.exception.CareemRuntimeException;
import com.careem.incentives.ms.promotion.interfaces.controller.json.IdModel.IdModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.ExpirationBatchUpdateModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromoCodeValidationRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionBatchUploadModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionCreditModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionDto;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionRedeemRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionRestModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionUpdateUserModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionValidationRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionValidationRequestForBooking;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.PromotionValidationResponse;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.SignupPromotionStillValidRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.SignupPromotionStillValidResponse;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.SignupValidationRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.SignupValidationResponse;
import com.careem.incentives.ms.promotion.interfaces.controller.json.promotion.ZoneValidationRequest;
import com.careem.incentives.ms.promotion.interfaces.controller.json.useravail.UserAvailedPromotionBookingRequestModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.useravail.UserAvailedPromotionRequestModel;
import com.careem.incentives.ms.promotion.interfaces.controller.json.useravail.UserAvailedPromotionResponseModel;
import com.careem.incentives.ms.promotion.interfaces.facade.PromotionValidationServiceFacade;
import com.careem.incentives.ms.promotion.service.configuration.PromotionFeature;
import com.careem.incentives.ms.promotion.service.domain.PromotionBatchService;
import com.careem.incentives.ms.promotion.service.domain.PromotionRedeemService;
import com.careem.incentives.ms.promotion.service.domain.PromotionService;
import com.careem.incentives.ms.promotion.service.domain.SignupPromotionValidationService;
import com.careem.incentives.ms.promotion.utils.TogglzUtils;
import com.careem.lib.commons.exception.DynamoDatabaseException;
import com.careem.lib.commons.exception.FacadeException;
import com.careem.lib.commons.json.model.ErrorResponse;
import com.careem.lib.commons.json.model.Response;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import javax.validation.Valid;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping(value = "/promotion")
public class PromotionController {

  private static final Logger LOG = LoggerFactory.getLogger(PromotionController.class);

  @Autowired
  private PromotionService promotionService;

  @Autowired
  private PromotionValidationServiceFacade promotionValidationServiceFacade;

  @Autowired
  private SignupPromotionValidationService signupPromotionValidationService;

  @Autowired
  private PromotionRedeemService promotionRedeemService;

  @Autowired
  private PromotionAttributesRepo promotionAttributesRepo;

  @Autowired
  private PromotionBatchService promotionBatchService;

  @Autowired
  private PromotionRepo promotionRepo;

  /*
  Unified endpoint that lists both promotion codes (promotion bookings) and vouchers (promotion credits)
  */
  @RequestMapping
  @ResponseStatus(HttpStatus.OK)
  public Response<Page<PromotionRestModel>> list(
      @RequestParam(defaultValue = "true") boolean isCurrent,
      @RequestParam(required = false) String promotionCode,
      @RequestParam(required = false) Integer promotionType,
      Pageable pageable) {
    Page<PromotionRestModel> promotionResponseModels =
        promotionRepo.listPromotions(isCurrent, promotionCode, promotionType, pageable);
    return new Response<>(promotionResponseModels);
  }

  @RequestMapping(method = {POST, PATCH})
  @ResponseStatus(HttpStatus.OK)
  public Response<IdModel> saveOrUpdate(@RequestBody PromotionRestModel request) {
    Promotion promotion = promotionRepo.save(PromotionRestModel.to(request));
    return new Response<>(new IdModel(promotion.getId()));
  }

  /*
   * Endpoint for gearbox
   */
  @RequestMapping(value = "/exists", method = GET)
  @ResponseStatus(HttpStatus.OK)
  public Response<List<String>> getExistingCodes(
      @RequestParam List<String> codes) {
    return new Response<>(promotionRepo.getExistingPromocodes(codes));
  }

  /*
   * Endpoint for customer demand growth
   */
  @RequestMapping(value = "/exists/{promoCode}", method = GET)
  @ResponseStatus(HttpStatus.OK)
  public Map<String, Object> promoCodeExists(@PathVariable String promoCode) {
    Long count = promotionRepo.countByPromoCode(promoCode);
    boolean exists = count.compareTo(0L) > 0;
    Map<String, Object> response = new HashMap<>();
    response.put("exists", exists);
    return response;
  }

  /*
  endpoint that returns promotion details of a promotion booking.
   */
  @RequestMapping("{id}")
  @ResponseStatus(HttpStatus.OK)
  public Response<PromotionRestModel> findDetailsById(
      @PathVariable Integer id) {
    Promotion promotion = promotionRepo.findOne(id);
    return new Response<>(PromotionRestModel.from(promotion));
  }

  @RequestMapping(value = "batch/upload", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.ACCEPTED)
  public void batchUpload(@RequestBody PromotionBatchUploadModel promotionBatchUploadModel) {
    promotionBatchService.batchUpload(
        promotionBatchUploadModel.getPromotionId(),
        promotionBatchUploadModel.getBatchSize(),
        promotionBatchUploadModel.getPromoCodes())
        .exceptionally(t -> {
          LOG.error("Error occurred during promo code batch upload : ", t);
          return null;
        });
  }

  @RequestMapping(value = "batch/upload/voucher", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.ACCEPTED)
  public void voucherBatchUpload(@RequestBody PromotionBatchUploadModel promotionBatchUploadModel) {
    promotionBatchService.voucherBatchUpload(
        promotionBatchUploadModel.getPromotionId(),
        promotionBatchUploadModel.getBatchSize(),
        promotionBatchUploadModel.getPromoCodes())
        .exceptionally(t -> {
          LOG.error("Error occurred during voucher batch upload : ", t);
          return null;
        });
  }

  @RequestMapping(value = "batch/update/expiration", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.ACCEPTED)
  public void expirationBatchUpdate(
      @RequestBody @Valid ExpirationBatchUpdateModel expirationBatchUpdateModel) {
    promotionBatchService.expirationBatchUpdate(
        expirationBatchUpdateModel.getPromoCodes(),
        expirationBatchUpdateModel.getBatchSize(),
        expirationBatchUpdateModel.getExpiration())
        .exceptionally(t -> {
          LOG.error("Error occurred during expiration batch update : ", t);
          return null;
        });
  }

  @RequestMapping(value = "/attributes/names", method = RequestMethod.GET)
  @ResponseStatus(HttpStatus.OK)
  public Response<List<String>> listPromotionAttributeNames() {
    return new Response<>(promotionAttributesRepo.listAllDistinctAttributeNames());
  }

  @RequestMapping(value = "/redeem", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.OK)
  public Response<UserAvailedPromotionResponseModel> redeem(
      @RequestBody UserAvailedPromotionRequestModel userAvailedPromotionModel) {
    return new Response<>(promotionRedeemService.redeemPromotion(userAvailedPromotionModel));

  }

  @RequestMapping(value = "/validate-redeem", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.OK)
  public Response<PromotionCreditModel> redeemAndValidate(
      @RequestBody PromotionRedeemRequest request) throws FacadeException {
    return new Response<>(promotionRedeemService.validateAndRedeemPromotion(request));
  }

  @RequestMapping(value = "/rollback/redeem/{userAvailedPromotionId}", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.OK)
  @ResponseBody
  public Response<Boolean> rollbackRedeem(@PathVariable Integer userAvailedPromotionId) {
    return new Response<>(promotionRedeemService.rollbackRedeemPromotion(userAvailedPromotionId));

  }

  @PostMapping(path = "validate")
  public ResponseEntity validatePromotion(
      @RequestBody PromotionValidationRequest promotionValidationRequest,
      @RequestParam Integer userId,
      @RequestHeader(value = "Error-Response-Version", required = false)
          String errorResponseVersion) {
    try {
      promotionValidationServiceFacade
          .validateUserPassengerAccessRight(userId, promotionValidationRequest.getClientId());
    } catch (final CareemRuntimeException ex) {
      final FacadeException facadeException = new FacadeException(
          CareemRuntimeException.toServiceException(ex));
      return handleFacadeException(facadeException, errorResponseVersion);
    }
    try {
      TogglzUtils.bind(promotionValidationRequest);

      List<PromotionValidationResponse> promotionValidationResponseList =
          promotionValidationServiceFacade
              .validateVouchersAndPromotions(promotionValidationRequest,
                  PromotionFeature.ENABLE_FAIL_FAST_FOR_PROMOTION_VALIDATION_API.isActive());

      return new ResponseEntity<>(new Response<>(promotionValidationResponseList), HttpStatus.OK);
    } catch (final FacadeException e) {
      return handleFacadeException(e, errorResponseVersion);
    }
  }

  private ResponseEntity handleFacadeException(final FacadeException exception,
      final String errorResponseVersionHeader) {
    final int statusCode = Optional.ofNullable(exception.getHttpStatus())
        .map(status -> status.getCode())
        .orElse(400);
    new CareemErrorResponse(null, null, null, null, exception)
        .getResponse();
    final ErrorResponse errorResponse = new ErrorResponse(exception.getAppCode(),
        exception.getAppMessage(), exception.getFields(), exception.getAppMessage());
    final Object response;
    final int errorResponseVersion = "3".equals(errorResponseVersionHeader) ? 3 : 2;
    if (errorResponseVersion == 3) {
      response = new Response<>(VALID_REQUEST_BUT_OP_FAILED.getCode(), errorResponse);
    } else {
      response = errorResponse;
    }
    final HttpHeaders headers = new HttpHeaders();
    headers.add("Error-Response-Version", Integer.toString(errorResponseVersion));
    final HttpStatus httpStatus = HttpStatus.valueOf(statusCode);
    return new ResponseEntity<>(response, headers, httpStatus);
  }

  @RequestMapping(value = "promotion-for-booking", method = RequestMethod.POST)
  public Response<PromotionDto> getPromotionForBooking(
      @RequestBody PromotionValidationRequestForBooking promotionValidationRequest)
      throws FacadeException {
    PromotionDto promotionDto = promotionValidationServiceFacade
        .validateVouchersAndPromotionsForBooking(promotionValidationRequest, false);
    return new Response(promotionDto);
  }

  @RequestMapping(value = "validate/promocode", method = RequestMethod.POST)
  public Response<PromotionValidationResponse> validatePromoCode(
      @RequestBody PromoCodeValidationRequest promotionValidationRequest)
      throws FacadeException {
    return new Response<>(
        promotionValidationServiceFacade.validatePromoCode(promotionValidationRequest, false));
  }

  @RequestMapping(value = "validate/zone", method = RequestMethod.POST)
  @ResponseBody
  public Response<PromotionValidationResponse> validatePromotionZone(
      @RequestBody ZoneValidationRequest zoneValidationRequest) throws FacadeException {
    return new Response<>(
        promotionValidationServiceFacade.validatePromotionZones(zoneValidationRequest));
  }

  /*
  This endpoint is used by solutions.
   */
  @RequestMapping(value = "list/all", method = RequestMethod.GET)
  public Response<List<PromotionBriefInfo>> listAllPromotionAndVoucherCodes(
      @RequestParam(required = false) Integer serviceAreaId,
      @RequestParam(required = false) Boolean isSignUpOnly,
      @RequestParam Integer serviceProviderId, @RequestParam String promoCode) {
    return new Response<>(promotionService.listAllPromotionAndVoucherCodes(
        serviceAreaId, isSignUpOnly, serviceProviderId, promoCode));
  }

  /*
  This endpoint is used by solutions.
   */
  @RequestMapping(value = "list/vouchers", method = RequestMethod.GET)
  public Response<List<PromotionBriefInfo>> listAllVoucherCodes(
      @RequestParam Integer serviceProviderId, @RequestParam String promoCode) {
    return new Response<>(promotionService.listAllVoucherCodes(serviceProviderId, promoCode));
  }

  @RequestMapping(value = "summary", method = RequestMethod.GET)
  public Response<PromoCodeLookup> findPromoCodesInRange(
      @RequestParam(required = false) String promoCode, @RequestParam Integer start,
      @RequestParam Integer limit) {
    return new Response<>(promotionService.findPromoCodesInRange(promoCode, start, limit));
  }

  @RequestMapping(value = "validate/signup", method = RequestMethod.POST)
  public Response<SignupValidationResponse> validateSignup(
      @RequestBody SignupValidationRequest signupValidationRequest)
      throws FacadeException {
    return new Response<>(
        signupPromotionValidationService.validateSignupPromotion(signupValidationRequest));
  }

  @RequestMapping(value = "findFirstByPromoCodeAndServiceProviderId", method = RequestMethod.GET)
  @ResponseBody
  public Response<PromotionRestModel> findFirstByPromoCodeAndServiceProviderId(
      @RequestParam String promotionCode, @RequestParam Integer serviceProviderId)
      throws FacadeException {
    return new Response<>(promotionService
        .findFirstByPromoCodeAndServiceProviderId(promotionCode, serviceProviderId));
  }

  @RequestMapping(value = "manage/promotion/updateuser", method = {POST})
  public Response<IdModel> updatePromotionUserIds(
      @RequestBody PromotionUpdateUserModel promotionUpdateUserModel)
      throws FacadeException, DynamoDatabaseException {

    IdModel idModel = promotionService.updatePromotionUserIds(promotionUpdateUserModel);
    return new Response<>(idModel);
  }

  @RequestMapping(value = "booking/redeem", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.OK)
  public Response<UserAvailedPromotionResponseModel> redeemPromotionBooking(
      @RequestBody UserAvailedPromotionBookingRequestModel userAvailedPromotionModel) {
    return new Response<>(promotionRedeemService.redeemPromotionBooking(userAvailedPromotionModel));

  }

  @Transactional(value = "promotion")
  @RequestMapping(value = "increase-usage-count/{promotionId}", method = RequestMethod.POST)
  @ResponseStatus(HttpStatus.CREATED)
  public Response<Map<String, Object>> increasePromotionUsageCount(
      @PathVariable Integer promotionId) {
    Integer promotionUsageCount = promotionRedeemService.increasePromotionUsageCount(promotionId);
    Map<String, Object> responseMap = new HashMap<>();
    responseMap.put("promotionUsageCount", promotionUsageCount);
    return new Response<>(responseMap);
  }

  @RequestMapping(value = "validate/signup/stillValid", method = RequestMethod.POST)
  public Response<SignupPromotionStillValidResponse> validateSignupPromotionStillValid(
      @RequestBody SignupPromotionStillValidRequest signupPromotionStillValidRequest)
      throws FacadeException {
    return new Response<>(signupPromotionValidationService
        .validateSignupPromotionStillValid(signupPromotionStillValidRequest));
  }

}