/**
 * Copyright (C) 2016 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.strata.calc.runner;

import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toList;

import java.io.Serializable;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;

import org.joda.beans.BeanDefinition;
import org.joda.beans.ImmutableBean;
import org.joda.beans.ImmutableValidator;
import org.joda.beans.JodaBeanUtils;
import org.joda.beans.MetaBean;
import org.joda.beans.Property;
import org.joda.beans.PropertyDefinition;
import org.joda.beans.impl.light.LightMetaBean;

import com.google.common.collect.ImmutableMap;
import com.opengamma.strata.basics.CalculationTarget;
import com.opengamma.strata.collect.ArgChecker;
import com.opengamma.strata.collect.MapStream;

/**
 * The default calculation functions implementation.
 * <p>
 * This provides the complete set of functions that will be used in a calculation.
 * Each {@link CalculationFunction} handles a specific type of {@link CalculationTarget},
 * thus the functions are keyed in a {@code Map} by the target type {@code Class}.
 */
@BeanDefinition(style = "light")
final class DefaultCalculationFunctions
    implements CalculationFunctions, ImmutableBean, Serializable {

  /**
   * An empty instance.
   */
  static final DefaultCalculationFunctions EMPTY = new DefaultCalculationFunctions(ImmutableMap.of());

  /**
   * The functions, keyed by target type.
   */
  @PropertyDefinition(validate = "notNull")
  private final ImmutableMap<Class<?>, CalculationFunction<?>> functions;

  //-------------------------------------------------------------------------
  /**
   * Obtains an instance from the specified functions.
   * <p>
   * The map will be validated to ensure the {@code Class} is consistent with
   * {@link CalculationFunction#targetType()}.
   * 
   * @param functions  the functions
   * @return the calculation functions
   */
  static DefaultCalculationFunctions of(Map<Class<?>, ? extends CalculationFunction<?>> functions) {
    return new DefaultCalculationFunctions(ImmutableMap.copyOf(functions));
  }

  @ImmutableValidator
  private void validate() {
    for (Entry<Class<?>, CalculationFunction<?>> entry : functions.entrySet()) {
      ArgChecker.isTrue(
          entry.getValue().targetType().isAssignableFrom(entry.getKey()),
          "Invalid map, key and function mismatch: {} and {}", entry.getKey(), entry.getValue().targetType());
    }
  }

  //-------------------------------------------------------------------------
  @Override
  public <T extends CalculationTarget> CalculationFunction<? super T> getFunction(T target) {
    @SuppressWarnings("unchecked")
    CalculationFunction<? super T> function = (CalculationFunction<? super T>) functions.get(target.getClass());
    return function != null ? function : MissingConfigCalculationFunction.INSTANCE;
  }

  @Override
  public <T extends CalculationTarget> Optional<CalculationFunction<? super T>> findFunction(T target) {
    @SuppressWarnings("unchecked")
    CalculationFunction<? super T> function = (CalculationFunction<? super T>) functions.get(target.getClass());
    return Optional.ofNullable(function);
  }

  @Override
  public CalculationFunctions composedWith(DerivedCalculationFunction<?, ?>... derivedFunctions) {
    // Override the default implementation for efficiency.
    // The default implementation uses DerivedCalculationFunctions which creates a function instance for every target.
    // This class can do better and can create a single function instance for each target type.
    Map<Class<?>, List<DerivedCalculationFunction<?, ?>>> functionsByTargetType =
        Arrays.stream(derivedFunctions).collect(groupingBy(fn -> fn.targetType()));

    // The calculation functions wrapped up with the derived functions which use them
    List<CalculationFunction<?>> wrappedFunctions = MapStream.of(functionsByTargetType)
        .map((targetType, fns) -> wrap(targetType, fns))
        .collect(toList());

    Map<Class<?>, CalculationFunction<?>> allFunctions = new HashMap<>(functions);
    wrappedFunctions.forEach(fn -> allFunctions.put(fn.targetType(), fn));
    return CalculationFunctions.of(allFunctions);
  }

  @SuppressWarnings("unchecked")
  private <T extends CalculationTarget, R> CalculationFunction<?> wrap(
      Class<?> targetType,
      List<DerivedCalculationFunction<?, ?>> derivedFunctions) {

    CalculationFunction<? super T> function = (CalculationFunction<? super T>) functions.get(targetType);

    if (function == null) {
      function = MissingConfigCalculationFunction.INSTANCE;
    }
    CalculationFunction<? super T> wrappedFn = function;

    for (DerivedCalculationFunction<?, ?> derivedFn : derivedFunctions) {
      // These casts are necessary because the type information is lost when the functions are stored in the map.
      // They are safe because T is the target type which is is the map key and R isn't actually used
      CalculationFunction<T> wrappedFnCast = (CalculationFunction<T>) wrappedFn;
      DerivedCalculationFunction<T, R> derivedFnCast = (DerivedCalculationFunction<T, R>) derivedFn;
      wrappedFn = new DerivedCalculationFunctionWrapper<>(derivedFnCast, wrappedFnCast);
    }
    return wrappedFn;
  }

  //------------------------- AUTOGENERATED START -------------------------
  ///CLOVER:OFF
  /**
   * The meta-bean for {@code DefaultCalculationFunctions}.
   */
  private static MetaBean META_BEAN = LightMetaBean.of(DefaultCalculationFunctions.class);

  /**
   * The meta-bean for {@code DefaultCalculationFunctions}.
   * @return the meta-bean, not null
   */
  public static MetaBean meta() {
    return META_BEAN;
  }

  static {
    JodaBeanUtils.registerMetaBean(META_BEAN);
  }

  /**
   * The serialization version id.
   */
  private static final long serialVersionUID = 1L;

  private DefaultCalculationFunctions(
      Map<Class<?>, CalculationFunction<?>> functions) {
    JodaBeanUtils.notNull(functions, "functions");
    this.functions = ImmutableMap.copyOf(functions);
    validate();
  }

  @Override
  public MetaBean metaBean() {
    return META_BEAN;
  }

  @Override
  public <R> Property<R> property(String propertyName) {
    return metaBean().<R>metaProperty(propertyName).createProperty(this);
  }

  @Override
  public Set<String> propertyNames() {
    return metaBean().metaPropertyMap().keySet();
  }

  //-----------------------------------------------------------------------
  /**
   * Gets the functions, keyed by target type.
   * @return the value of the property, not null
   */
  public ImmutableMap<Class<?>, CalculationFunction<?>> getFunctions() {
    return functions;
  }

  //-----------------------------------------------------------------------
  @Override
  public boolean equals(Object obj) {
    if (obj == this) {
      return true;
    }
    if (obj != null && obj.getClass() == this.getClass()) {
      DefaultCalculationFunctions other = (DefaultCalculationFunctions) obj;
      return JodaBeanUtils.equal(functions, other.functions);
    }
    return false;
  }

  @Override
  public int hashCode() {
    int hash = getClass().hashCode();
    hash = hash * 31 + JodaBeanUtils.hashCode(functions);
    return hash;
  }

  @Override
  public String toString() {
    StringBuilder buf = new StringBuilder(64);
    buf.append("DefaultCalculationFunctions{");
    buf.append("functions").append('=').append(JodaBeanUtils.toString(functions));
    buf.append('}');
    return buf.toString();
  }

  ///CLOVER:ON
  //-------------------------- AUTOGENERATED END --------------------------
}