import { v4 as uuidv4 } from 'uuid';

import { DurationUnitEnum } from '../enums/duration-unit.enum';
import { TicketTypeEnum } from '../enums/ticket-type.enum';
import { ValidationState } from '../enums/validation-state';
import { ProductVariant } from '../interfaces/product-variant';
import { TicketDatesOutput } from '../interfaces/ticket/ticket.dates.output';
import { TicketDto } from '../interfaces/ticket/ticket.dto';
import { ValidateTicketArgs } from '../interfaces/validation/validate-ticket.args';
import { Validation } from '../interfaces/validation/validation.model';
import { VanillaDurationCalculationService } from '../services/vanilla-duration-calculation.service';
import { canValidate } from './validate';
import {
  getDurationAsSecondBetweenForDateRange,
  getTicketDatesByType,
  getTicketType,
} from './validation-utils';

export function ticketValidationOffline(
  ticket: TicketDto,
  validateTicketArgs: ValidateTicketArgs,
): Validation {
  if (!ticket.offlineValidation) {
    throw Error('Offline validation not allowed for this ticket');
  }

  if (!canValidate(ticket)) {
    return {
      id: uuidv4(),
      state: ValidationState.INVALID,
      validFrom: null,
      validUntil: null,
      passengers: 1,
    };
  }

  const vanillaValidationService: VanillaDurationCalculationService =
    new VanillaDurationCalculationService();

  const validationDate: Date = validateTicketArgs?.input?.validationDate ?? new Date();
  const productVariant: ProductVariant = ticket?.orderLine?.productVariant;
  const ticketType: TicketTypeEnum =
    ticket.ticketType ??
    getTicketType(productVariant?.validityDateFrom, productVariant?.validityDateUntil);
  const ticketDates: TicketDatesOutput = getTicketDatesByType(ticket, ticketType, validationDate);

  if (ticket.validationDurationValue === -1) {
    ticket.validationDurationValueUnit = DurationUnitEnum.SECOND;
    ticket.validationDurationValue = getDurationAsSecondBetweenForDateRange(
      ticket.dateFrom,
      ticket.dateUntil,
    );
  }

  const validatedValidationDate = vanillaValidationService.computeValidationDate({
    fromDate: ticketType === TicketTypeEnum.CALENDAR ? ticketDates.dateFrom : validationDate,
    timeUnit: ticket.validationDurationValueUnit,
    timeValue: ticket.validationDurationValue,
    ticketType: ticketType,
    validityDateUntil: ticketDates.dateUntil,
    overrideUnit: null,
    overrideEndingHour: ticket.hourOfExpiration,
    validationDateBehavior: ticket.validationBehaviour,
  });

  return {
    id: uuidv4(),
    state: ValidationState.VALID,
    validFrom: validatedValidationDate.validFrom,
    validUntil: validatedValidationDate.validUntil,
    dateFrom: ticket.dateFrom ?? ticketDates.dateFrom,
    dateUntil: ticket.dateUntil ?? ticketDates.dateUntil,
    passengers: validateTicketArgs.input.passengers,
  };
}