import { StoreState } from 'app/common/store/store.types';
import datePipe from 'app/shared/pipes/date.pipe';
import { createSelector } from 'reselect';
import { EarningsXlsRow, AverageEarnings, TcePreviousPeriodsMonths } from './earnings.types';
import { getCurrentPoolName } from 'app/shared/services/filters/filters.service';
import { getLoadingStatus } from 'app/shared/modules/loading/getStatus';
import { TCE } from './earnings.constants';
import { getQuarterlyLabel, MONTHLY, QUARTERLY, YEARLY } from 'app/shared/services/aggregationPeriods/aggregationPeriods.service';
import { selectFilters } from 'app/shared/store/filters/filters.selectors';

const vesselEarningsStateSlice = (state: StoreState) => state.earnings;

export const selectTce = (state: StoreState) => vesselEarningsStateSlice(state).tce;
export const selectEarnings = (store: StoreState) => vesselEarningsStateSlice(store).vessels.collection;
export const selectPoolAverage = (store: StoreState) => vesselEarningsStateSlice(store).vessels.poolAverage;
export const selectFilteredAverage = (store: StoreState) => vesselEarningsStateSlice(store).vessels.filteredAverage;
export const selectNumberOfEarningsVessels = (store: StoreState) => vesselEarningsStateSlice(store).vessels.collection?.length;
export const selectTceKeyValues = (store: StoreState) => selectTce(store).keyValues;
export const selectIsEarningsPageLoading = (store: StoreState) => getLoadingStatus([ TCE.FETCH_SELECTOR ])(store);
export const selectTcePagination = (state: StoreState) => selectTce(state).pagination;
export const selectTceAggregations = (state: StoreState) => selectTce(state).aggregations;
export const selectTceBenchmarkMode = (state: StoreState) => selectTce(state).benchmarkMode;
export const selectCurrentAggregation = (state: StoreState) => selectTce(state).selectedAggregation;

export const selectIsPaginatedFlag = (state: StoreState) => selectTcePagination(state).numberOfPages > 1;

export const selectCurrentTcePeriod = createSelector(
  selectTceAggregations,
  selectCurrentAggregation,
  selectFilters,
  (aggregations, selectedIndex, filters) => {
    if (!aggregations || selectedIndex === undefined) {
      return '';
    }

    const selectedAggregation = aggregations[selectedIndex || 0]?.date;

    return selectedAggregation ? getTcePeriodLabel(new Date(selectedAggregation), filters.aggregationPeriodId) : '';
  }
);

const getTcePeriodLabel = (date: Date, periodId: number): string => {
  switch (periodId) {
    case QUARTERLY:
      return getQuarterlyLabel(date);
    case YEARLY:
      return date.getFullYear().toString();
    default:
      return datePipe.formatLongMonthWithYear(date);
  }
};

export const selectPreviousTceMonths =
  createSelector(
    selectTceAggregations,
    selectCurrentAggregation,
    selectFilters,
    (aggregations, selectedIndex, filters) => {
      const { aggregationPeriodId: periodId } = filters;
      const months = {} as TcePreviousPeriodsMonths;

      if (!aggregations || selectedIndex === null) {
        return months;
      }

      if (selectedIndex - 1 >= 0) {
        const date = aggregations[selectedIndex - 1]?.date;
        months.previousLabel = date ? getTcePeriodLabel(new Date(date), periodId) : '';
      }

      if (periodId === QUARTERLY && selectedIndex - 5 >= 0) {
        const date = aggregations[selectedIndex - 5]?.date;
        months.previousYearLabel = date ? getTcePeriodLabel(new Date(date), periodId) : '';
      }
      else if (periodId === MONTHLY && selectedIndex - 12 >= 0) {
        const date = aggregations[selectedIndex - 12]?.date;
        months.previousYearLabel = date ? getTcePeriodLabel(new Date(date), periodId) : '';
      }

      return months;
    }
  );

export const selectEarningsXlsName = createSelector(store => getCurrentPoolName(store), (name) => `${name}-vessels-`);

const mapAverageToXls = (average: AverageEarnings): EarningsXlsRow => ({
  name: average?.names?.join(', '),
  hasScrubber: '-',
  poolPoints: Number(average?.poolPoints?.toFixed(2)),
  bunkerAdjustmentPerDay: Number(average?.bunkerAdjustmentPerDay?.toFixed(2)),
  earnings: Number(average?.earnings?.toFixed(2)),
  bunkerAdjustment: Number(average?.bunkerAdjustment?.toFixed(2)),
  scrubberBonus: Number(average?.scrubberBonus?.toFixed(2)),
  wafDta: Number(average?.wafDta?.toFixed(2)),
  specialCompensations: Number(average?.specialCompensations?.toFixed(2)),
  tce: Number(average?.tce?.toFixed(2)),
});

export const selectEarningsXlsData = createSelector(
  selectPoolAverage,
  selectFilteredAverage,
  selectEarnings,
  (poolAverage, filteredAverage, earnings): EarningsXlsRow[] => {
    const xlsData: EarningsXlsRow[] = poolAverage ? [
      mapAverageToXls(poolAverage),
    ] : [];

    if (filteredAverage) {
      xlsData.push(mapAverageToXls(filteredAverage));
    }

    if (earnings) {
      xlsData.push(...earnings.map((item): EarningsXlsRow => ({
        name: item.name,
        hasScrubber: item.hasScrubber ? 'Yes' : 'No',
        poolPoints: Number(item.poolPoints?.toFixed(2)),
        bunkerAdjustmentPerDay: Number(item.bunkerAdjustmentPerDay?.toFixed(2)),
        earnings: Number(item.earnings?.toFixed(2)),
        bunkerAdjustment: Number(item.bunkerAdjustment?.toFixed(2)),
        scrubberBonus: Number(item.scrubberBonus?.toFixed(2)),
        wafDta: Number(item.wafDta?.toFixed(2)),
        specialCompensations: Number(item.specialCompensations?.toFixed(2)),
        tce: Number(item.tce?.toFixed(2)),
      })));
    }

    return xlsData;
  }
);

export const selectActivePoolId = (store: StoreState) => store.filters.poolId;