export function singularizeLastWord(name:string) {
    const parts = getWords(name);
    if (parts.length == 0) {
        return name;
    }
    const lastWord = parts.pop();
    const lastPos = name.lastIndexOf(lastWord);

    return name.substr(0, lastPos) + plural.singular(lastWord) + name.substr(lastPos + lastWord.length);
}

export const storeReference = (scope: string, identifier: string, store?: Store | string) => {
  if (!store) {
    return singular(identifier);
  }
  else if (typeof(store) === 'string') {
    return store;
  }
  else {
    invariant(store instanceof Store,
      `${scope} - A valid store reference of either a \`String\` or \`Store\` type must be passed, ` +
      `but found type \`${typeof(store)}\`.`
    );
  }

  return store;
};

export const createSchemaCollection = (path: string, options: IKeyValue = {}): SchemaPath => {
  let collectionPath: SchemaPath;
  let memberIdentifier: string;
  let memberId: string;
  let identifier: string;

  invariant(typeof(path) === 'string', `createSchemaCollection: expected string path identifier but found \`${path}\``);
  // tslint:disable-next-line:max-line-length
  invariant(isPlainObject(options), `createSchemaCollection: expected object options identifier but found \`${options}\``);

  path = validatePath('schema/createSchemaCollection', path);
  identifier = options.identifier || cleanIdentifier(path);

  // Collection Node

  collectionPath = createSchemaPath(
    new SchemaNode(IClassification.collection, identifier, extend({
      store: storeReference('schema/createSchemaCollection', identifier, options.store),
      path
    }, options.collection))
  );

  // Member Node

  memberIdentifier = singular(identifier);
  if (memberIdentifier === identifier) {
    memberIdentifier = 'member';
    memberId = identifier + 'Id';
  }
  else {
    memberId = memberIdentifier + 'Id';
  }

  collectionPath.addLeaf(
    new SchemaNode(IClassification.item, memberIdentifier, extend({
      paramId: memberId
    }, options.member))
  );

  return collectionPath;
};

export function singular(plural?: string | null) {
  return plural ? pluralize.singular(plural) : plural;
}

 ...(_.differenceWith(relationFields, relationTableFields, (a, b) => {
   // TODO: Manage this ugly hack if finding relation field in 
   // directive of relation table field 
   // there is also plural to singular hack in this
   return b.directives.join('').indexOf(pluralize.singular(a.name)) > -1
 })),