import hash from 'object-hash';
import { isNonNullable } from '~/utils';
import { invitationLinkedObject } from '~/utils/linkedObject/invitationLinkedObject';
import { pullFromCache, pushToCache } from '~/cache/api';
import { sortByFirstCreated, sortByLastCreated } from '~/core/query';
import { MyInvitationsPaginationController } from './MyInvitationsPaginationController';
import { MyInvitationsQueryStreamController } from './MyInvitationsQueryStreamController';
import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
import {
  onLocalInvitationCreated,
  onLocalInvitationDeleted,
  onLocalInvitationUpdated,
} from '~/invitationRepository/events';
import { prepareMyInvitationsPayload } from '~/invitationRepository/utils/prepareMyInvitationsPayload';
import { InvitationActionsEnum } from '../getInvitations/enums';

export class MyInvitationsLiveCollectionController extends LiveCollectionController<
  'myInvitation',
  Amity.MyInvitationsLiveCollection,
  Amity.Invitation,
  MyInvitationsPaginationController
> {
  private queryStreamController: MyInvitationsQueryStreamController;

  private query: Amity.MyInvitationsLiveCollection;

  constructor(
    query: Amity.MyInvitationsLiveCollection,
    callback: Amity.LiveCollectionCallback<Amity.Invitation>,
  ) {
    const queryStreamId = hash(query);
    const cacheKey = ['invitation', 'collection', queryStreamId];
    const paginationController = new MyInvitationsPaginationController(query);

    super(paginationController, queryStreamId, cacheKey, callback);

    this.query = query;
    this.queryStreamController = new MyInvitationsQueryStreamController(
      this.query,
      this.cacheKey,
      this.notifyChange.bind(this),
      prepareMyInvitationsPayload,
    );

    this.callback = callback.bind(this);
    this.loadPage({ initial: true });
  }

  protected setup() {
    const collection = pullFromCache<Amity.MyInvitationsLiveCollectionCache>(this.cacheKey)?.data;
    if (!collection) {
      pushToCache(this.cacheKey, {
        data: [],
        params: this.query,
      });
    }
  }

  protected async persistModel(queryPayload: Amity.MyInvitationsPayload & Amity.Pagination) {
    await this.queryStreamController.saveToMainDB(queryPayload);
  }

  protected persistQueryStream({
    response,
    direction,
    refresh,
  }: Amity.LiveCollectionPersistQueryStreamParams<'myInvitation'>) {
    this.queryStreamController.appendToQueryStream(response, direction, refresh);
  }

  startSubscription() {
    return this.queryStreamController.subscribeRTE([
      {
        fn: onLocalInvitationCreated,
        action: InvitationActionsEnum.OnLocalInvitationCreated,
      },
      {
        fn: onLocalInvitationUpdated,
        action: InvitationActionsEnum.OnLocalInvitationUpdated,
      },
      {
        fn: onLocalInvitationDeleted,
        action: InvitationActionsEnum.OnLocalInvitationDeleted,
      },
    ]);
  }

  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
    const collection = pullFromCache<Amity.MyInvitationsLiveCollectionCache>(this.cacheKey)?.data;
    if (!collection) return;

    const data = this.applyFilter(
      collection.data
        .map(id => pullFromCache<Amity.InternalInvitation>(['invitation', 'get', id])!)
        .filter(isNonNullable)
        .map(({ data }) => invitationLinkedObject(data)) ?? [],
    );

    if (!this.shouldNotify(data) && origin === 'event') return;

    this.callback({
      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
      data,
      hasNextPage: !!this.paginationController.getNextToken(),
      loading,
      error,
    });
  }

  applyFilter(data: Amity.Invitation[]) {
    let invitations = data;

    if (this.query.targetId) {
      invitations = invitations.filter(invitation => invitation.targetId === this.query.targetId);
    }

    if (this.query.statuses) {
      invitations = invitations.filter(invitation =>
        this.query.statuses?.includes(invitation.status),
      );
    }

    if (this.query.targetType) {
      invitations = invitations.filter(
        invitation => invitation.targetType === this.query.targetType,
      );
    }

    if (this.query.type) {
      invitations = invitations.filter(invitation => invitation.type === this.query.type);
    }

    const sortFn = (() => {
      switch (this.query.sortBy) {
        case 'firstCreated':
          return sortByFirstCreated;
        case 'lastCreated':
          return sortByLastCreated;
        default:
          return sortByLastCreated;
      }
    })();

    invitations = invitations.sort(sortFn);

    return invitations;
  }
}