// @flow
import qs from 'query-string';

import type { ConnectionArguments } from 'graphql-relay';

import * as ConnectionUtil from '../ConnectionUtil';

import type { GraphQLContext, Edge } from '../../TypeDefinition';
import type { OffsetsOptions, Offsets, PageInfoOptions, PageInfo } from '../ConnectionUtil';

import api from './api';

export const PREFIX = 'rest:';

export const cursorToOffset = (cursor: string): number => ConnectionUtil.cursorToOffset(PREFIX, cursor);

export const offsetToCursor = (offset: number): string => ConnectionUtil.offsetToCursor(PREFIX, offset);

export const getOffsetWithDefault = (cursor: string, defaultOffset: number): number =>
  ConnectionUtil.getOffsetWithDefault(PREFIX, cursor, defaultOffset);

export const calculateOffsets = (options: OffsetsOptions): Offsets => ConnectionUtil.calculateOffsets(PREFIX, options);

export const getPageInfo = ({
  edges,
  before,
  after,
  first,
  last,
  afterOffset,
  beforeOffset,
  startOffset,
  endOffset,
  totalCount,
}: PageInfoOptions): PageInfo => {
  const firstEdge = edges[0];
  const lastEdge = edges[edges.length - 1];
  const lowerBound = after ? afterOffset + 1 : 0;
  const upperBound = before ? Math.min(beforeOffset, totalCount) : totalCount;

  return {
    startCursor: firstEdge ? firstEdge.cursor : null,
    endCursor: lastEdge ? lastEdge.cursor : null,
    hasPreviousPage: last !== null ? startOffset > lowerBound : false,
    hasNextPage: first !== null ? endOffset < upperBound : false,
  };
};

// TODO - implement this
type ConnectionOptions = {
  // Endpoint URL
  endpoint: String,
  // Headers
  headers?: Object,
  // QueryString
  query?: Object,
  // API params
  params?: {
    // Endpoint URL
    endpoint: String,
    // Headers
    headers: Object,
    // QueryString
    query?: Object,
  },
  // GraphQL context
  context: GraphQLContext,
  // Connection Args
  args: ConnectionArguments,
  // Loader to load individually objects
  loader: (context: GraphQLContext, id: string) => Object,
  // data from api already loaded
  edges?: Edge[],
};
const connectionFromRest = async ({
  context,
  loader,
  args = {},
  callApi: (skip: number, limit: number) => Promise<any>
}: ConnectionOptions) => {
  const totalCount = 10000;
  const {
    first,
    last,
    before,
    after,
    skip: _skip,
    limit: _limit,
    beforeOffset,
    afterOffset,
    startOffset,
    endOffset,
  } = calculateOffsets({ args, totalCount });

  // TODO - use skip and limit here
  try {
    const data = await callApi(skip, limit);

    const edges = data.map((value, index) => ({
      cursor: offsetToCursor(startOffset + index),
      // TODO - not sure if this is needed
      node: loader(context, value),
    }));

    return {
      edges,
      count: totalCount,
      pageInfo: getPageInfo({
        edges,
        before,
        after,
        first,
        last,
        afterOffset,
        beforeOffset,
        startOffset,
        endOffset,
        totalCount,
      }),
    };
  } catch (err) {
    console.log(new Error('ConnectionFromRest: ', err));
    return null;
  }
};

export default connectionFromRest;