import _ from 'lodash';

import { RECEIVE_ANNOTATIONS, RECEIVE_MESSAGES_COUNT } from '../actions';

import { isDefinitionInTags } from '../utils';

/**

 * termsMap is a mapping { term: [annotations,...] }

 * where annotation

 */

function getDefinitionsAndReferences(annotations, termsMap) {

  return Object.keys(termsMap).reduce((res, term) => {

    res[term] = res[term] || {

      keywordAnnotations: termsMap[term],

      definitions: [],

      references: [],

    };

    termsMap[term].forEach((annotation) => {

      const annotationText = (annotation.text && annotation.text.trim()) || '';

      const tags = annotation.tags.map(t => t.toLowerCase());

      if (annotationText && isDefinitionInTags(tags)) {

        const annotationObj = annotation;

        annotationObj.isPersonal = true;

        res[term].definitions.push(annotationObj);

      }

    });

    annotations.forEach((annotation) => {

      const tags = annotation.tags.map(t => t.toLowerCase());

      if (isDefinitionInTags(tags) && tags.includes(term.toLowerCase())) {

        const annotationObj = annotation;

        annotationObj.isPersonal = false;

        res[term].definitions.push(annotationObj);

      } else {

        let exactText;

        (annotation.target[0].selector || []).some((selector) => {

          if (selector.type === 'TextQuoteSelector' && selector.exact) {

            exactText = selector.exact.trim().toLowerCase();

            return true;

          }

          return false;

        });

        if (exactText && exactText.includes(term.toLowerCase()) && !tags.includes('cat:mot-clef')) {

          res[term].references.push(annotation);

        }

      }

    });

    return res;

  }, {});

}

/**

 * Calculate stats on terms

 */

function addTermStats(termsMap) {

  return _.reduce(

    termsMap,

    (res, termDef, term) => {

      res[term] = _.assign({

        definitionsNb: (termDef.definitions || []).length,

        referenceNb: (termDef.references || []).length,

      }, termDef);

      return res;

    },

    {},

  );

}

function terms(

  state = {

  },

  action,

) {

  switch (action.type) {

    case RECEIVE_ANNOTATIONS: {

      const { annotations } = action;

      // let termsMap = getTerms(annotations);

      let termsMap = action.terms;

      termsMap = getDefinitionsAndReferences(annotations, termsMap);

      return Object.assign({}, state, addTermStats(termsMap));

    }

    case RECEIVE_MESSAGES_COUNT: {

      const { terms: termList, messagesCount: counts } = action;

      const termCountMap = _.zipObject(termList, counts);

      return Object.assign({}, state, _.mapValues(

        state,

        (termDef, term) => Object.assign(

          {},

          termDef,

          { messagesCount: termCountMap[term] || 0 },

        ),

      ));

    }

    default:

      return state;

  }

}

export default terms;