package org.folio.search.service.setter.instance;

import static org.folio.search.utils.SearchUtils.INSTANCE_RESOURCE;
import static org.folio.search.utils.SearchUtils.getMultilangValue;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import org.apache.commons.collections4.MapUtils;
import org.folio.search.model.metadata.PlainFieldDescription;
import org.folio.search.service.metadata.LocalSearchFieldProvider;
import org.springframework.stereotype.Component;

@Component
@RequiredArgsConstructor
public class AllSearchFieldValueProvider {

  private final LocalSearchFieldProvider searchFieldProvider;
  private final ConcurrentHashMap<String, Boolean> multilangCache = new ConcurrentHashMap<>();

  public Map<String, Object> getFieldValue(Map<String, Object> eventBody, List<String> languages) {
    var instanceEventBody = new LinkedHashMap<>(eventBody);
    instanceEventBody.remove("items");
    instanceEventBody.remove("holdings");

    var resultMap = new LinkedHashMap<String, Object>();

    resultMap.putAll(getAllFields("allInstances", instanceEventBody, languages));
    resultMap.putAll(getAllFields("allItems", eventBody.get("items"), languages));
    resultMap.putAll(getAllFields("allHoldings", eventBody.get("holdings"), languages));

    return resultMap;
  }

  @SuppressWarnings("unchecked")
    private Map<String, Object> getAllFields(String field, Object eventBody, List<String> languages) {
    if (eventBody == null) {
      return Collections.emptyMap();
    }

    var context = new Context();
    addStrings(null, context, eventBody);

    var resultMap = getMultilangValue(field, new LinkedHashSet<>(context.getMultilangValues()), languages);

    var plainField = PLAIN_MULTILANG_PREFIX + field;
    var newPlainAll = new LinkedHashSet<>((Set<String>) resultMap.get(plainField));
    newPlainAll.addAll(context.getPlainValues());
    resultMap.put(plainField, newPlainAll);

    return resultMap;
  }

  private void addStrings(String path, Context context, Collection<?> collection) {
    if (collection.isEmpty()) {
      return;
    }

    for (Object value : collection) {
      addStrings(path, context, value);
    }
  }

  @SuppressWarnings("unchecked")
  private void addStrings(String path, Context context, Object value) {
    if (value instanceof String) {
      context.addValue((String) value, isMultilang(path));
    }

    if (value instanceof Collection<?>) {
      addStrings(path, context, (Collection<?>) value);
    }

    if (value instanceof Map<?, ?>) {
      addStrings(path, context, (Map<String, Object>) value);
    }
  }

  private static String getPath(String initValue, String path) {
    return initValue != null ? initValue + "." + path : path;
  }

  private boolean isMultilang(String path) {
    var isMultilang = multilangCache.get(path);
    if (isMultilang != null) {
      return isMultilang;
    }

    var result = searchFieldProvider.getPlainFieldByPath(INSTANCE_RESOURCE, path)
      .filter(PlainFieldDescription::isMultilang)
      .isPresent();

    multilangCache.put(path, result);
    return result;
  }

  @Data
  private static class Context {

    private Collection<String> plainValues = new ArrayList<>();
    private Collection<String> multilangValues = new ArrayList<>();

    void addValue(String value, boolean isMultilang) {
      if (isMultilang) {
        multilangValues.add(value);
        return;
      }

      plainValues.add(value);
    }
  }
}

"properties":{
  "all": {
    "properties": {
      "eng": {
        "type": "text",
        "analyzer": "english"
      },
      "fre": {
        "type": "text",
        "analyzer": "french"
      },
      "ger": {
        "type": "text",
        "analyzer": "german"
      },
      "ita": {
        "type": "text",
        "analyzer": "italian"
      },
      "spa": {
        "type": "text",
        "analyzer": "spanish"
      },
      "src": {
        "type": "text",
        "analyzer": "source_analyzer"
      }
    }
  },
  "plain_all": {
    "type": "keyword",
    "normalizer": "keyword_lowercase"
  }
}