import { gql } from 'graphql-request';
import { execute } from 'test/graphql';
import { Page, Product } from '@/entities';
import { ProductSource } from '@/entities/types';
import { sequence } from '@/utils';

describe('Query:pages', () => {
  const query = gql`
    query Pages(
      $input: PagesInput
      $first: Float
      $last: Float
      $before: String
      $after: String
    ) {
      pages(
        input: $input
        first: $first
        last: $last
        before: $before
        after: $after
      ) {
        totalCount
        count
        pageInfo {
          hasNextPage
          hasPreviousPage
          startCursor
          endCursor
        }
        edges {
          cursor
          node {
            id
          }
        }
        nodes {
          id
          createdAt
          featured
        }
      }
    }
  `;

  test('filter by url', async () => {
    const exampleUrl = 'www.amazon.com/dp/B07JQQQQQQQ';

    const product = await Product.create({
      firebaseId: 'product-id',
      source: ProductSource.GOOGLE_SHOPPING,
    }).save();

    const differentProduct = await Product.create({
      firebaseId: 'different-product-id',
      source: ProductSource.GOOGLE_SHOPPING,
    }).save();

    const page1 = await Page.create({
      url: exampleUrl,
      firebaseId: 'page-id',
      price: 10,
      retailer: 'amazon',
      productFirebaseId: product.firebaseId,
      discoverable: true,
    }).save({ listeners: false });

    const page2 = await Page.create({
      url: 'www.google.com/dp/B07JQQQQQQQRAQJJ',
      firebaseId: 'page-id-2',
      price: 10,
      retailer: 'google',
      productFirebaseId: product.firebaseId,
      discoverable: true,
    }).save({ listeners: false });

    await Page.create({
      url: 'www.netflix.com/dp/B07JQQQQQQQRAQJJ',
      firebaseId: 'page-id-3',
      price: 10,
      retailer: 'netflix',
      productFirebaseId: differentProduct.firebaseId,
      discoverable: true,
    }).save({ listeners: false });

    const { data, errors } = await execute({
      query,
      variables: {
        input: {
          url: exampleUrl,
        },
      },
    });

    expect(errors).toBeFalsy();

    expect(data?.pages).toMatchObject({
      totalCount: 2,
      nodes: [{ id: page1.id }, { id: page2.id }],
    });
  });

  test('handles sorting', async () => {
    const product = await Product.create({
      firebaseId: 'product-id',
      source: ProductSource.GOOGLE_SHOPPING,
    }).save();

    // 7 pages
    await sequence(
      [...new Array(7)].map((_, idx) => async () => {
        await Page.create({
          url: 'www.netflix.com/dp/B07JQQQQQQQRAQJJ',
          firebaseId: `page-id-${idx}`,
          price: 10,
          retailer: 'netflix',
          productFirebaseId: product.firebaseId,
          discoverable: true,
          featured: idx % 2 === 0, // make every other featured
        }).save({ listeners: false });
        // must wait so each report gets a unique createdAt
        await new Promise((resolve) => setTimeout(resolve, 5));
      })
    );
    const { data: defaultOrderedData, errors: defaultOrderedErrors } =
      await execute({
        query,
      });

    expect(defaultOrderedErrors).toBeFalsy();
    expect(defaultOrderedData?.pages?.count).toBe(7);
    expect(defaultOrderedData?.pages?.totalCount).toBe(7);
    expect(defaultOrderedData?.pages?.nodes?.length).toBe(7);
    const nodes = defaultOrderedData?.pages?.nodes as Page[];
    // the first 4 nodes should be featured=true and the last 3 should be featured=false,
    expect(nodes.slice(0, 4).every((node) => node.featured)).toBe(true);
  });
});