import test from 'ava';
import { Types } from 'mongoose';

import { Factory } from '../../../database/factory';
import * as testUtils from '../../../test/utils';
import { RecipeCollection } from '../collection-model';
import { Recipe } from '../../recipe';
import { User } from '../../../app/user';
import { createContext } from '../../../test/utils/create-mock-context';
import { defineUserAbility } from '../../../server/authorization/user-authorization';
import { AuthenticationError } from 'apollo-server-micro';
import { removeRecipesFromCollection } from '../schema/remove-recipes';
import { SmartRecipeCollection } from '../smart-collection-model';
import { removeFiltersFromCollection } from '../schema/remove-filters';

test.before(testUtils.setupDB);
test.afterEach.always(testUtils.cleanupDB);
test.after.always(testUtils.tearDownDB);

//
// Tests
//

test.serial('Should remove Filters from a Recipe Collection', async t => {
  const user = await Factory.create<User>('user');
  const context = createContext({
    state: { user, abilities: defineUserAbility(user) },
  });
  const collection = await Factory.create<SmartRecipeCollection>(
    'smartCollection',
    {},
    { user, filterCount: 2 }
  );

  const updatedCollection = await removeFiltersFromCollection(
    null,
    {
      input: {
        recipeCollectionId: collection.id,
        filters: [collection.filters[0].id],
      },
    },
    context,
    null
  );

  const dbCollection = await SmartRecipeCollection.findById(collection.id);

  t.is(updatedCollection.recipeCollection.filters.length, 1);
  t.is(updatedCollection.removedFilters.length, 1);
  t.is(dbCollection.filters.length, 1);
});

test.failing('Should return RecipeCollection with Updated Recipes', async t => {
  const user = await Factory.create<User>('user');
  const context = createContext({
    state: { user, abilities: defineUserAbility(user) },
  });
  const collection = await Factory.create<RecipeCollection>(
    'collection',
    {},
    { user, filterCount: 2 }
  );

  const updatedCollection = await removeFiltersFromCollection(
    null,
    {
      input: {
        recipeCollectionId: collection.id,
        filters: [collection.filters[0].id],
      },
    },
    context,
    null
  );
});

test.serial('Should reject Filters that are not in the collection', async t => {
  const user = await Factory.create<User>('user');
  const context = createContext({
    state: { user, abilities: defineUserAbility(user) },
  });
  const collection = await Factory.create<SmartRecipeCollection>(
    'smartCollection',
    {},
    { user, filterCount: 2 }
  );

  const unknownFilterId = Types.ObjectId().toHexString();

  const response = await removeFiltersFromCollection(
    null,
    {
      input: {
        recipeCollectionId: collection.id,
        filters: [unknownFilterId],
      },
    },
    context,
    null
  );

  t.is(response.rejectedFilters[0], unknownFilterId);
});

test.serial(
  'Should return an error when the user is not logged in',
  async t => {
    const context = createContext({
      state: { user: null, abilities: defineUserAbility(null) },
    });

    await t.throwsAsync(async () => {
      return removeFiltersFromCollection(
        null,
        {
          input: {
            recipeCollectionId: '',
            filters: [],
          },
        },
        context,
        null
      );
    }, AuthenticationError);
  }
);