import { objectType, enumType, unionType, inputObjectType } from '@nexus/schema';
import { reject } from 'lodash';

import { Measurement } from '../';
import { NodeType } from '../../../schema/node';
import {
  IngredientListItemKind,
  IngredientList,
  IngredientGroup,
} from '../ingredient-list-model';

// import('../../../../types/nexus/generated');

export const MeasurementEnum = enumType({
  name: 'Measurement',
  description: 'All available ingredient measurement types',
  members: Measurement,
});

export const ILItemTypeEnum = enumType({
  name: 'IngredientListItemType',
  description: 'All available ingredient measurement types',
  members: IngredientListItemKind,
});

// Ingredient
export const IngredientType = objectType({
  name: 'Ingredient',
  definition(t) {
    t.field('measurement', {
      type: MeasurementEnum,
    });
    t.string('name', { description: 'The Ingredient name' });
    t.string('note', { description: 'An optional ingredient note' });
    t.float('quantity', { description: 'The quantity of the ingredient' });
  },
});

export const IngredientItemType = objectType({
  name: 'IngredientItem',
  definition(t) {
    t.implements('Node');
    t.int('order', {
      resolve: root => {
        const owner = root.parent() as IngredientList | IngredientGroup;
        return owner.nodes.indexOf(root);
      },
    });
    t.field('node', {
      type: 'Ingredient',
    });
  },
});

// Ingredient List Group Item
export const IngredientGroupType = objectType({
  name: 'IngredientGroup',
  definition(t) {
    t.implements('Node');
    t.int('order', {
      description: 'The order that this item appears in the Ingredient List',
      resolve: root => {
        const owner = root.parent() as IngredientList;
        return owner.nodes.indexOf(root);
      },
    });
    t.string('heading', {
      description: 'The name of the group',
      nullable: true,
    });
    t.list.field('nodes', {
      type: 'IngredientItem',
    });
  },
});

// Union of either Single or Group Item
export const ILItemType = unionType({
  name: 'IngredientListItem',
  description:
    'An IngredientList Item. Will either be a single item, or a item group',
  definition(t) {
    t.members('IngredientItem', 'IngredientGroup');
    t.resolveType(item => {
      switch (item.kind) {
        case IngredientListItemKind.GROUP:
          return IngredientGroupType.name;
          break;
        case IngredientListItemKind.SINGLE:
          return IngredientItemType.name;
          break;
        default:
          return null;
      }
    });
  },
});

// Ingredient List
export const IngredientListType = objectType({
  name: 'IngredientList',
  definition(t) {
    t.list.field('nodes', { type: ILItemType });
  },
});

//
// Inputs
//

// Base Ingredient input
export const IngredientInputType = inputObjectType({
  name: 'IngredientInput',
  definition(t) {
    t.field('measurement', { type: MeasurementEnum });
    t.string('name');
    t.float('quantity');
    t.string('note');
  },
});

export const IngredientGroupInputType = inputObjectType({
  name: 'IngredientGroupInput',
  definition(t) {
    t.field('heading', { type: IngredientInputType });
    t.list.field('items', { type: IngredientInputType });
  },
});

// Export
export { AddIngredientInputType, addIngredientMF } from './add-ingredient';
export {
  UpdateIngredientInputType,
  updateIngredientMF,
} from './update-ingredient';
export {
  RemoveIngredientInputType,
  removeIngredientMF,
} from './remove-ingredient';
export {
  AddIngredientGroupInputType,
  addIngredienGrouptMF,
} from './add-ingredient-group';
export {
  UpdateIngredientGroupInputType,
  updateIngredientGroupMF,
} from './update-ingredient-group';
export {
  RemoveIngredientGroupInputType,
  removeIngredientGroupMF,
} from './remove-ingredient-group';