import { combineEpics, ofType } from 'redux-observable';
import {
  BI,
  FINANCE_REPORT,
} from 'app/modules/reports/store/bi.constants';
import { catchError, map, switchMap } from 'rxjs/operators';
import { ENTERED_REPORTS_PAGE } from 'app/common/store/router/router.constants';
import {
  findLast,
  get,
} from 'lodash';
import {
  biFetchReportsFailure,
  biFetchReportsRequest,
  biFetchReportsSuccess,
  biFetchReportTokenFailure,
  biFetchReportTokenRequest,
  biFetchReportTokenSuccess,
  biSetFinanceReport,
  biSetFinanceReportToken,
  biSetFinanceReportYear,
  biSetReports,
  biSetReportsFilters,
} from 'app/modules/reports/store/bi.actions';
import { resetAllFilters, setPoolFilter } from 'app/shared/store/filters/filters.actions';
import { guardRedirectToForbidden } from 'app/shared/store/guard/guard.actions';
import ReactGA from 'react-ga';
import { PretypedEpic } from '../../../common/store/store.types';
import { of } from 'rxjs';
import { BiReport, BiReports } from './bi.types';
import { AnyAction } from 'redux';

export const fetchBiReportsEpic: PretypedEpic<string> = (action$, store, { bi }) => {
  return action$.pipe(
    ofType(BI.FETCH_REPORTS_REQUEST),
    switchMap((action) => bi.getBiReports(action.payload).pipe(
      map((reports) => [
        biFetchReportsSuccess(reports),
      ]),
      catchError(() => of(biFetchReportsFailure()))
    )),
  );
};

export const fetchBiReportsSuccessEpic: PretypedEpic<BiReports> = (action$, store) => {
  return action$.pipe(
    ofType(BI.FETCH_REPORTS_SUCCESS),
    map((action) => action.payload),
    map((payload) => {
      let actions = [
        biSetReports(payload.reports),
        biSetReportsFilters({
          years: payload.years,
          types: payload.types,
        }),
      ];
      const currentReportYear = store.value.bi.reports.year;
      const reportsYears = payload.years;
      const isCurrentYearReportAvailable = currentReportYear && reportsYears.includes(currentReportYear);
      const lastYear = Math.max(...reportsYears);

      if (reportsYears.length && !isCurrentYearReportAvailable) {
        actions.push(biSetFinanceReportYear(lastYear));
      } else if (isCurrentYearReportAvailable) {
        actions.push(biSetFinanceReportYear(currentReportYear));
      }

      return actions;
    }),
  );
};

export const setFinanceReportEpic: PretypedEpic<BiReport> = (action$) => {
  return action$.pipe(
    ofType(BI.SET_FINANCE_REPORT),
    map((action) => biFetchReportTokenRequest(action.payload)),
  );
};

export const setFinanceReportYearEpic: PretypedEpic<number> = (action$, store) => {
  return action$.pipe(
    ofType(BI.SET_FINANCE_REPORT_YEAR),
    map((action) => {
      const reports = store.value.bi.reports.collection;
      const reportForYear = findLast(reports, { year: action.payload });

      return biSetFinanceReport(reportForYear);
    }),
  );
};

export const fetchBiReportTokenEpic: PretypedEpic<BiReport> = (action$, store, { bi }) => {
  return action$.pipe(
    ofType(BI.FETCH_REPORT_TOKEN_REQUEST),
    map((action) => action.payload),
    switchMap((report) => bi.getBiReportToken(report.datasetId, report.id, report.workspaceId).pipe(
      map((payload) => [
        biFetchReportTokenSuccess(payload.token),
      ]),
      catchError(() => of(biFetchReportTokenFailure()))
    )),
  );
};


export const fetchBiReportTokenSuccessEpic: PretypedEpic<string> = (action$) => {
  return action$.pipe(
    ofType(BI.FETCH_REPORT_TOKEN_SUCCESS),
    map((action) => biSetFinanceReportToken(action.payload)),
  );
};

export const enteredReportsPageEpic: PretypedEpic<{ pool: number }> = (action$, store) => {
  return action$.pipe(
    ofType(ENTERED_REPORTS_PAGE),
    map((action) => {
      const { pools, partner, isStaff } = store.value.user.data;
      const partnerAxCode = partner ? partner.map((item) => item.axCode).join(' ') : 'not-set';

      ReactGA.event({
        category: 'Reports',
        action: 'Reports - page opened',
        label: `isStaff: ${isStaff}, partnerAxCode: ${partnerAxCode}`,
      });

      const requestedPool = get(action, 'payload.pool');
      if (requestedPool && !pools.includes(requestedPool)){
        return guardRedirectToForbidden();
      }
      let actions: AnyAction[] = [
        biFetchReportsRequest(FINANCE_REPORT.workspaceId),
        setPoolFilter(action.payload.pool),
      ];
      if (store.value.filters.poolId !== action.payload.pool) {
        actions.push(resetAllFilters());
      }
      return actions;
    }),
  );
};

const biEpic = combineEpics(
  fetchBiReportsEpic,
  fetchBiReportsSuccessEpic,
  enteredReportsPageEpic,
  fetchBiReportTokenEpic,
  fetchBiReportTokenSuccessEpic,
  setFinanceReportEpic,
  setFinanceReportYearEpic,
);

export { biEpic };