import { ApolloLink, Observable, Operation, NextLink, FetchResult } from 'apollo-link';
import { ApolloClient } from 'apollo-client';
import auth from './helpers/auth';
import unwrap from './helpers/unwrap';
import events from './events';

export default class AuthLink extends ApolloLink {
  tokenRefreshingPromise: Promise<boolean> | undefined;

  client: ApolloClient<{}> | undefined;

  injectClient = (client: ApolloClient<{}>): void => {
    this.client = client;
  };

  refreshToken = (): Promise<boolean> => {
    if (!this.tokenRefreshingPromise) {
      this.tokenRefreshingPromise = auth.exchangeToken();
    }
    return this.tokenRefreshingPromise;
  };

  setTokenHeader = (operation: Operation): void => {
    const { token } = auth;
    if (token) {
      operation.setContext({ headers: { authorization: `Bearer ${token}` } });
    }
  };

  request(operation: Operation, forward?: NextLink): Observable<FetchResult> {
    // set token in header
    this.setTokenHeader(operation);
    const next = unwrap(forward);
    // try refreshing token once if it has expired
    return new Observable(observer => {
      let subscription: ZenObservable.Subscription;
      let innerSubscription: ZenObservable.Subscription;
      try {
        subscription = next(operation).subscribe({
          next: observer.next.bind(observer),
          complete: observer.complete.bind(observer),
          error: networkError => {
            if (networkError.statusCode === 401) {
              this.refreshToken()
                .then(success => {
                  if (success) {
                    // set new token and retry operation
                    this.setTokenHeader(operation);
                    innerSubscription = next(operation).subscribe(observer);
                  } else {
                    // throw error
                    observer.error(new Error('jwt refresh failed'));
                  }
                })
                .catch(() => {
                  events.emit('unauthorized');
                });
            } else {
              observer.error(networkError);
            }
          },
        });
      } catch (e) {
        observer.error(e);
      }
      return () => {
        if (subscription) subscription.unsubscribe();
        if (innerSubscription) innerSubscription.unsubscribe();
      };
    });
  }
}