import {
  filter, 
  includes, some,
} from 'lodash/fp';
import { getAllIdsIterator } from '../indexing/allIds';
import {
  getFlattenedHierarchy, getRecordNodeById,
  getNode, isIndex,
  isRecord, getAllowedRecordNodesForIndex,
  fieldReversesReferenceToIndex,
} from '../templateApi/hierarchy';
import {
  joinKey, apiWrapper, events, $
} from '../common';
import {
  createBuildIndexFolder,
  transactionForBuildIndex,
} from '../transactions/create';
import { permission } from '../authApi/permissions';
import { BadRequestError } from '../common/errors';


/** rebuilds an index
 * @param {object} app - the application container
 * @param {string} indexNodeKey - node key of the index, which the index belongs to
 */
export const buildIndex = app => async indexNodeKey => apiWrapper(
  app,
  events.indexApi.buildIndex,
  permission.manageIndex.isAuthorized,
  { indexNodeKey },
  _buildIndex, app, indexNodeKey,
);

const _buildIndex = async (app, indexNodeKey) => {
  const indexNode = getNode(app.hierarchy, indexNodeKey);

  await createBuildIndexFolder(app.datastore, indexNodeKey);

  if (!isIndex(indexNode)) { throw new BadRequestError('BuildIndex: must supply an indexnode'); }

  if (indexNode.indexType === 'reference') {
    await buildReverseReferenceIndex(
      app, indexNode,
    );
  } else {
    await buildHeirarchalIndex(
      app, indexNode,
    );
  }

  await app.cleanupTransactions();
};

const buildReverseReferenceIndex = async (app, indexNode) => {
  // Iterate through all referencING records,
  // and update referenced index for each record
  let recordCount = 0;
  const referencingNodes = $(app.hierarchy, [
    getFlattenedHierarchy,
    filter(n => isRecord(n)
                    && some(fieldReversesReferenceToIndex(indexNode))(n.fields)),
  ]);

  const createTransactionsForReferencingNode = async (referencingNode) => {
    const iterateReferencingNodes = await getAllIdsIterator(app)(referencingNode.collectionNodeKey());

    let referencingIdIterator = await iterateReferencingNodes();
    while (!referencingIdIterator.done) {
      const { result } = referencingIdIterator;
      for (const id of result.ids) {
        const recordKey = joinKey(result.collectionKey, id);
        await transactionForBuildIndex(app, indexNode.nodeKey(), recordKey, recordCount);
        recordCount++;
      }
      referencingIdIterator = await iterateReferencingNodes();
    }
  };

  for (const referencingNode of referencingNodes) {
    await createTransactionsForReferencingNode(referencingNode);
  }
};

/*
const getAllowedParentCollectionNodes = (hierarchy, indexNode) => $(getAllowedRecordNodesForIndex(hierarchy, indexNode), [
  map(n => n.parent()),
]);
*/

const buildHeirarchalIndex = async (app, indexNode) => {
  let recordCount = 0;

  const createTransactionsForIds = async (collectionKey, ids) => {
    for (const recordId of ids) {
      const recordKey = joinKey(collectionKey, recordId);

      const recordNode = getRecordNodeById(
        app.hierarchy,
        recordId,
      );

      if (recordNodeApplies(indexNode)(recordNode)) {
        await transactionForBuildIndex(
          app, indexNode.nodeKey(),
          recordKey, recordCount,
        );
        recordCount++;
      }
    }
  };


  const collectionRecords = getAllowedRecordNodesForIndex(app.hierarchy, indexNode);

  for (const targetCollectionRecordNode of collectionRecords) {
    const allIdsIterator = await getAllIdsIterator(app)(targetCollectionRecordNode.collectionNodeKey());

    let allIds = await allIdsIterator();
    while (allIds.done === false) {
      await createTransactionsForIds(
        allIds.result.collectionKey,
        allIds.result.ids,
      );
      allIds = await allIdsIterator();
    }
  }

  return recordCount;
};

// const chooseChildRecordNodeByKey = (collectionNode, recordId) => find(c => recordId.startsWith(c.nodeId))(collectionNode.children);

const recordNodeApplies = indexNode => recordNode => includes(recordNode.nodeId)(indexNode.allowedRecordNodeIds);

/*
const hasApplicableDecendant = (hierarchy, ancestorNode, indexNode) => $(hierarchy, [
  getFlattenedHierarchy,
  filter(
    allTrue(
      isRecord,
      isDecendant(ancestorNode),
      recordNodeApplies(indexNode),
    ),
  ),
]);
*/

 /*
const applyAllDecendantRecords = async (app, collection_Key_or_NodeKey,
  indexNode, indexKey, currentIndexedData,
  currentIndexedDataKey, recordCount = 0) => {
  const collectionNode = getCollectionNodeByKeyOrNodeKey(
    app.hierarchy,
    collection_Key_or_NodeKey,
  );

  const allIdsIterator = await getAllIdsIterator(app)(collection_Key_or_NodeKey);


  const createTransactionsForIds = async (collectionKey, allIds) => {
    for (const recordId of allIds) {
      const recordKey = joinKey(collectionKey, recordId);

      const recordNode = chooseChildRecordNodeByKey(
        collectionNode,
        recordId,
      );

      if (recordNodeApplies(indexNode)(recordNode)) {
        await transactionForBuildIndex(
          app, indexNode.nodeKey(),
          recordKey, recordCount,
        );
        recordCount++;
      }

      if (hasApplicableDecendant(app.hierarchy, recordNode, indexNode)) {
        for (const childCollectionNode of recordNode.children) {
          recordCount = await applyAllDecendantRecords(
            app,
            joinKey(recordKey, childCollectionNode.collectionName),
            indexNode, indexKey, currentIndexedData,
            currentIndexedDataKey, recordCount,
          );
        }
      }
    }
  };

  let allIds = await allIdsIterator();
  while (allIds.done === false) {
    await createTransactionsForIds(
      allIds.result.collectionKey,
      allIds.result.ids,
    );
    allIds = await allIdsIterator();
  }

  return recordCount;
};
*/

export default buildIndex;