/**
 * Copyright (C) 2014-2016 LinkedIn Corp. (pinot-core@linkedin.com)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.linkedin.pinot.core.query.aggregation;

import com.google.common.base.Preconditions;
import com.linkedin.pinot.core.common.BlockValSet;
import com.linkedin.pinot.core.operator.blocks.TransformBlock;
import com.linkedin.pinot.core.query.aggregation.function.AggregationFunction;
import com.linkedin.pinot.core.query.aggregation.function.AggregationFunctionFactory;
import java.util.ArrayList;
import java.util.List;


/**
 * Implementation of AggregationExecutor interface, to perform
 * aggregations.
 */
public class DefaultAggregationExecutor implements AggregationExecutor {
  private final int _numAggrFunc;
  private final AggregationFunctionContext[] _aggrFuncContextArray;

  // Array of result holders, one for each aggregation.
  private final AggregationResultHolder[] _resultHolderArray;

  boolean _inited = false;
  boolean _finished = false;

  public DefaultAggregationExecutor(AggregationFunctionContext[] aggrFuncContextArray) {
    Preconditions.checkNotNull(aggrFuncContextArray);
    Preconditions.checkArgument(aggrFuncContextArray.length > 0);

    _numAggrFunc = aggrFuncContextArray.length;
    _aggrFuncContextArray = aggrFuncContextArray;
    _resultHolderArray = new AggregationResultHolder[_numAggrFunc];
  }

  @Override
  public void init() {
    if (_inited) {
      return;
    }

    for (int i = 0; i < _numAggrFunc; i++) {
      _resultHolderArray[i] = _aggrFuncContextArray[i].getAggregationFunction().createAggregationResultHolder();
    }
    _inited = true;
  }

  /**
   * {@inheritDoc}
   * Perform aggregation on a given docIdSet.
   * Asserts that 'init' has be called before calling this method.
   *
   * @param transformBlock Block upon which to perform aggregation.
   */
  @Override
  public void aggregate(TransformBlock transformBlock) {
    Preconditions.checkState(_inited,
        "Method 'aggregate' cannot be called before 'init' for class " + getClass().getName());

    for (int i = 0; i < _numAggrFunc; i++) {
      aggregateColumn(transformBlock, _aggrFuncContextArray[i], _resultHolderArray[i]);
    }
  }

  /**
   * Helper method to perform aggregation for a given column.
   *
   * @param aggrFuncContext aggregation function context.
   * @param resultHolder result holder.
   */
  @SuppressWarnings("ConstantConditions")
  private void aggregateColumn(TransformBlock transformBlock, AggregationFunctionContext aggrFuncContext,
      AggregationResultHolder resultHolder) {
    AggregationFunction aggregationFunction = aggrFuncContext.getAggregationFunction();
    String[] aggregationColumns = aggrFuncContext.getAggregationColumns();
    Preconditions.checkState(aggregationColumns.length == 1);
    int length = transformBlock.getNumDocs();

    if (!aggregationFunction.getName().equals(AggregationFunctionFactory.AggregationFunctionType.COUNT.getName())) {
      BlockValSet blockValSet = transformBlock.getBlockValueSet(aggregationColumns[0]);
      aggregationFunction.aggregate(length, resultHolder, blockValSet);
    } else {
      aggregationFunction.aggregate(length, resultHolder);
    }
  }

  @Override
  public void finish() {
    Preconditions.checkState(_inited,
        "Method 'finish' cannot be called before 'init' for class " + getClass().getName());

    _finished = true;
  }

  @Override
  public List<Object> getResult() {
    Preconditions.checkState(_finished,
        "Method 'getResult' cannot be called before 'finish' for class " + getClass().getName());

    List<Object> aggregationResults = new ArrayList<>(_numAggrFunc);

    for (int i = 0; i < _numAggrFunc; i++) {
      AggregationFunction aggregationFunction = _aggrFuncContextArray[i].getAggregationFunction();
      aggregationResults.add(aggregationFunction.extractAggregationResult(_resultHolderArray[i]));
    }

    return aggregationResults;
  }
}