import { combineEpics, ofType } from 'redux-observable';
import { setPoolFilter } from 'app/shared/store/filters';
import { ENTERED_DOCUMENTS_PAGE } from 'app/common/store/router/router.constants';
import {
  documentsAddBookmarkFailure,
  documentsAddBookmarkSuccess,
  documentsFetchBookmarksFailure,
  documentsFetchBookmarksRequest, documentsFetchBookmarksSuccess, documentsFetchCollectionFailure,
  documentsFetchCollectionRequest,
  documentsFetchCollectionSuccess, documentsRemoveBookmarkFailure, documentsRemoveBookmarkSuccess,
  documentsSetCategories,
  resetDocumentsCollectionLimit,
  setDocumentsCollection,
} from 'app/modules/documents/store/documents.actions';
import { resetAllFilters } from 'app/shared/store/filters/filters.actions';
import { DOCUMENTS } from 'app/modules/documents/store/documents.constants';
import { catchError, ignoreElements, map, mergeMap } from 'rxjs/operators';
import { PretypedEpic } from 'app/common/store/store.types';
import { AnyAction } from 'redux';
import { of } from 'rxjs';


export const enteredDocumentsPageEpic: PretypedEpic<{ pool: number }> = (action$, store) => {
  return action$.pipe(
    ofType(ENTERED_DOCUMENTS_PAGE),
    map((action) => {
      let actions: AnyAction[] = [
        documentsFetchCollectionRequest(action.payload.pool),
        documentsFetchBookmarksRequest(),
      ];
      if (store.value.filters.poolId !== action.payload.pool) {
        actions.push(resetAllFilters());
      }
      return actions;
    }
    )
  );
};

export const fetchDocumentsEpic: PretypedEpic<number> = (action$, _, { documentsService }) => {
  return action$.pipe(
    ofType(DOCUMENTS.FETCH_COLLECTION_REQUEST),
    mergeMap((action) => documentsService.getDocumentsCategories()
      .pipe(
        map((documentCategories) => ({ pool: action.payload, documentCategories })))),
    mergeMap((data) => documentsService.getDocuments(data.pool).pipe(
      map((documents) => ({
        pool: data.pool,
        documentCategories: data.documentCategories,
        documents,
      })))),
    map((data) => [
      documentsSetCategories(data.documentCategories),
      setPoolFilter(data.pool),
      setDocumentsCollection(data.documents),
      resetDocumentsCollectionLimit(),
      documentsFetchCollectionSuccess(),
    ]),
    catchError(() => of(documentsFetchCollectionFailure()))
  );
};

export const getDocumentFileEpic: PretypedEpic<number> = (action$, _, { documentsService }) => {
  return action$.pipe(
    ofType(DOCUMENTS.GET_FILE),
    mergeMap((action) =>
      documentsService.getDocumentUrl(action.payload)),
    map((documentUrl) => window.location.assign(documentUrl)),
    ignoreElements()
  );
};

export const getDocumentBookmarksEpic: PretypedEpic<undefined> = (action$, _, { documentsService }) => {
  return action$.pipe(
    ofType(DOCUMENTS.FETCH_BOOKMARKS_REQUEST),
    mergeMap(() => documentsService.getBookmarks().pipe(
      map(bookmarks => documentsFetchBookmarksSuccess(bookmarks.bookmarks)),
      catchError(() => of(documentsFetchBookmarksFailure()))
    ))
  );
};

export const addDocumentBookmarksEpic: PretypedEpic<number> = (action$, _, { documentsService }) => {
  return action$.pipe(
    ofType(DOCUMENTS.ADD_BOOKMARK_REQUEST),
    mergeMap(action => documentsService.addBookmark(action.payload).pipe(
      map(bookmark => documentsAddBookmarkSuccess(bookmark.bookmark)),
      catchError(() => of(documentsAddBookmarkFailure()))
    ))
  );
};

export const removeDocumentBookmarksEpic: PretypedEpic<number> = (action$, _, { documentsService }) => {
  return action$.pipe(
    ofType(DOCUMENTS.REMOVE_BOOKMARK_REQUEST),
    mergeMap(action => documentsService.removeBookmark(action.payload).pipe(
      map(bookmark => documentsRemoveBookmarkSuccess(bookmark.bookmark)),
      catchError(() => of(documentsRemoveBookmarkFailure()))
    ))
  );
};

export const documentsEpics = combineEpics(
  enteredDocumentsPageEpic,
  getDocumentFileEpic,
  fetchDocumentsEpic,
  getDocumentBookmarksEpic,
  addDocumentBookmarksEpic,
  removeDocumentBookmarksEpic,
);