export const createExchangeLink = () => {
  const httpLink = createHttpLink({
    fetch,
    uri: urljoin(EXCHANGE_API_BASE, "graphql"),
  })

  const authMiddleware = setContext((_request, context) => {
    const locals = context.graphqlContext && context.graphqlContext.res.locals
    const tokenLoader = locals && locals.dataLoaders.exchangeTokenLoader
    const headers = { ...(locals && requestIDHeaders(locals.requestIDs)) }
    // If a token loader exists for Exchange (i.e. this is an authenticated request), use that token to make
    // authenticated requests to Exchange.
    if (tokenLoader) {
      return tokenLoader().then(({ token }) => {
        return {
          headers: Object.assign(headers, { Authorization: `Bearer ${token}` }),
        }
      })
    }
    // Exchange uses no authentication for now
    return { headers }
  })

  return middlewareLink.concat(authMiddleware).concat(httpLink)
}

function createAuthLink(tokenService: TokenService) {
    const authLink = setContext((operation: GraphQLRequest, prevContext: any) => {
        const jwt: string = tokenService.getToken();

        if (!jwt) {
            return {};
        } else {
            return {
                headers: { Authorization: `Bearer ${jwt}` }
            };
        }
    });
    return authLink;
}

  constructor(apollo: Apollo, httpLink: HttpLink) {
    const http = httpLink.create({ uri: `${environment.apiAddress}/graphql` });

    const middleware = setContext(() => ({
      headers: new HttpHeaders().set(
        'Sandwich-Auth-Token',
        localStorage.getItem('token') || ''
      )
    }));

    const error = onError(({ networkError, graphQLErrors }) => {
      console.error(networkError);

      window.location.pathname = '/login';
    });

    const link = middleware.concat(error).concat(http);

    apollo.create({
      link,
      cache: new InMemoryCache({
        dataIdFromObject: (o: any) => {
          let key;
          switch (o.__typename) {
            case 'user':
              key = `${o.__typename}-${o.userId},`;
              break;
            case 'week':
              key = `${o.__typename}-${o.weekId},`;
              break;
            case 'weekUserLink':
              key = `${o.__typename}-${o.weekId}-${o.userId},`;
              break;
            default:
              key = `${o.__typename}-${o.id},`;
              break;
          }

          return key;
        }
      })
    });
  }

import {InMemoryCache} from "apollo-cache-inmemory";
import {store} from "@/store";

const httpLink = createHttpLink({
    uri: process.env.NODE_ENV==="development"?"http://127.0.0.1:3000/api/graphql":"https://budgetarium.herokuapp.com/api/graphql",
});
const authLinkAccess = setContext((_: any, {headers}: any) => {
    // get the authentication token from local storage if it exists
    if (store.getState().auth.accessToken) {
        const token = (store.getState().auth.accessToken as any).token;
        // return the headers to the context so httpLink can read them
        return {
            headers: {
                ...headers,
                authorization: token ? `Bearer ${token}` : "",
            }
        };
    } else {
        return {
            headers: {
                ...headers,
            }
        };
    }
});


const authLinkRefresh = setContext((_: any, {headers}: any) => {
    // get the authentication token from local storage if it exists
    if (store.getState().auth.refreshToken) {
        const token = (store.getState().auth.refreshToken as any).token;

const wsLink = new WebSocketLink({
  uri: wsUri,
  options: {
    reconnect: true,
    connectionParams: () => ({
      authToken: getAuthHeader(),
    }),
  },
})

const authLink = setContext((_, { headers }) => {
  const auth = getAuthHeader()

  return {
    headers: {
      ...headers,
      Authorization: auth,
    },
  }
})

const terminatingLink = split(
  ({ query }) => {
    const { kind, operation } = getMainDefinition(query) as OperationDefinitionNode
    return kind === 'OperationDefinition' && operation === 'subscription'
  },
  wsLink,
  authLink.concat(httpLink),
)

const link = ApolloLink.from([terminatingLink])

import { getEnvironmentVariables } from './utils';
import AuthService from './utils/authentication/authService';

const { graphcoolApi, devMode } = getEnvironmentVariables();
if (process.env.NODE_ENV === 'development') {
  console.log('Trying to connect to: ', graphcoolApi);
}

const httpLink = createHttpLink({ uri: graphcoolApi });
const middlewareLink = setContext(() => {
  let authHeader;
  const bearerToken = AuthService.getBearerToken();
  if (bearerToken) {
    authHeader = `Bearer ${bearerToken}`;
  }

  return {
    headers: {
      authorization: authHeader || null
      // TODO: Figure out if we should include a nonce header for graphcool
    }
  };
});

// Create a RestLink for the REST API
// If you are using multiple link types, restLink should go before httpLink,
// as httpLink will swallow any calls that should be routed through rest!
const restLink = new RestLink({
  endpoints: {
    github: 'https://api.github.com/'
  },
  credentials: 'omit',

export function createApolloClient() {
  const graphqlApiUrl = getGraphQLEndpoint(
    process.env.REACT_APP_LOCAL_API ? 'graphqlApiUrlLocal' : 'graphqlApiUrl',
  );

  const httpLink = createHttpLink({ uri: graphqlApiUrl });
  const authLink = setContext((_, { headers }) => {
    return {
      headers: {
        ...headers,
        authorization: appInitializer.getBearerToken() || null,
      },
    };
  });

  const subscriptionsApiUrl = getGraphQLEndpoint(
    process.env.REACT_APP_LOCAL_API
      ? 'subscriptionsApiUrlLocal'
      : 'subscriptionsApiUrl',
  );
  const wsLink = new WebSocketLink({
    uri: subscriptionsApiUrl,
    options: {
      reconnect: true,
    },
  });
  const cache = new InMemoryCache();

  const authHttpLink = authLink.concat(httpLink);
  const errorLink = onError(
    ({ operation, response, graphQLErrors, networkError }) => {
      if (process.env.REACT_APP_ENV !== 'production') {
        if (graphQLErrors) {
          graphQLErrors.map(({ message, locations, path }) =>
            // tslint:disable-next-line
            console.error(
              `[GraphQL error]: Message: ${message}, Location: ${locations}, Path: ${path}`,
            ),
          );
        }

        // tslint:disable-next-line
        if (networkError) console.error(`[Network error]: ${networkError}`);
      }
    },
  );
  const link = split(
    ({ query }) => {
      const { kind, operation } = getMainDefinition(query);
      return kind === 'OperationDefinition' && operation === 'subscription';
    },
    wsLink,
    authHttpLink,
  );

  const client = new ApolloClient({
    link: ApolloLink.from([errorLink, link]),
    cache,
    connectToDevTools: true,
  });

  return client;
}