// Copyright (C) 2013 The Android Open Source Project
//
// 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.google.gerrit.server.index;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Function;
import com.google.common.base.Objects;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.gerrit.server.query.Predicate;
import com.google.gerrit.server.query.QueryParseException;
import com.google.gerrit.server.query.change.ChangeData;
import com.google.gerrit.server.query.change.ChangeDataSource;
import com.google.gerrit.server.query.change.Paginated;
import com.google.gerrit.server.query.change.SortKeyPredicate;
import com.google.gwtorm.server.OrmException;
import com.google.gwtorm.server.ResultSet;

import java.util.Collection;
import java.util.Iterator;
import java.util.List;

/**
 * Wrapper combining an {@link IndexPredicate} together with a
 * {@link ChangeDataSource} that returns matching results from the index.
 * <p>
 * Appropriate to return as the rootmost predicate that can be processed using
 * the secondary index; such predicates must also implement
 * {@link ChangeDataSource} to be chosen by the query processor.
 */
public class IndexedChangeQuery extends Predicate<ChangeData>
    implements ChangeDataSource, Paginated {

  /**
   * Replace all {@link SortKeyPredicate}s in a tree.
   * <p>
   * Strictly speaking this should replace only the {@link SortKeyPredicate} at
   * the top-level AND node, but this implementation is simpler, and the
   * behavior of having multiple sortkey operators is undefined anyway.
   *
   * @param p predicate to replace in.
   * @param newValue new cut value to replace all sortkey operators with.
   * @return a copy of {@code p} with all sortkey predicates replaced; or p
   *     itself.
   */
  @VisibleForTesting
  static Predicate<ChangeData> replaceSortKeyPredicates(
      Predicate<ChangeData> p, String newValue) {
    if (p instanceof SortKeyPredicate) {
      return ((SortKeyPredicate) p).copy(newValue);
    } else if (p.getChildCount() > 0) {
      List<Predicate<ChangeData>> newChildren =
          Lists.newArrayListWithCapacity(p.getChildCount());
      boolean replaced = false;
      for (Predicate<ChangeData> c : p.getChildren()) {
        Predicate<ChangeData> nc = replaceSortKeyPredicates(c, newValue);
        newChildren.add(nc);
        if (nc != c) {
          replaced = true;
        }
      }
      return replaced ? p.copy(newChildren) : p;
    } else {
      return p;
    }
  }

  private final ChangeIndex index;
  private final int limit;

  private Predicate<ChangeData> pred;
  private ChangeDataSource source;

  public IndexedChangeQuery(ChangeIndex index, Predicate<ChangeData> pred,
      int limit) throws QueryParseException {
    this.index = index;
    this.limit = limit;
    this.pred = pred;
    this.source = index.getSource(pred, 0, limit);
  }

  @Override
  public int getChildCount() {
    return 1;
  }

  @Override
  public Predicate<ChangeData> getChild(int i) {
    if (i == 0) {
      return pred;
    }
    throw new ArrayIndexOutOfBoundsException(i);
  }

  @Override
  public List<Predicate<ChangeData>> getChildren() {
    return ImmutableList.of(pred);
  }

  @Override
  public int limit() {
    return limit;
  }

  @Override
  public int getCardinality() {
    return source != null ? source.getCardinality() : limit();
  }

  @Override
  public boolean hasChange() {
    return index.getSchema().getFields()
        .containsKey(ChangeField.CHANGE.getName());
  }

  @Override
  public ResultSet<ChangeData> read() throws OrmException {
    final ChangeDataSource currSource = source;
    final ResultSet<ChangeData> rs = currSource.read();

    return new ResultSet<ChangeData>() {
      @Override
      public Iterator<ChangeData> iterator() {
        return Iterables.transform(
            rs,
            new Function<ChangeData, ChangeData>() {
              @Override
              public
              ChangeData apply(ChangeData input) {
                input.cacheFromSource(currSource);
                return input;
              }
            }).iterator();
      }

      @Override
      public List<ChangeData> toList() {
        List<ChangeData> r = rs.toList();
        for (ChangeData cd : r) {
          cd.cacheFromSource(currSource);
        }
        return r;
      }

      @Override
      public void close() {
        rs.close();
      }
    };
  }

  @Override
  public ResultSet<ChangeData> restart(ChangeData last) throws OrmException {
    pred = replaceSortKeyPredicates(pred, last.change().getSortKey());
    try {
      source = index.getSource(pred, 0, limit);
    } catch (QueryParseException e) {
      // Don't need to show this exception to the user; the only thing that
      // changed about pred was its SortKeyPredicates, and any other QPEs
      // that might happen should have already thrown from the constructor.
      throw new OrmException(e);
    }
    return read();
  }

  @Override
  public ResultSet<ChangeData> restart(int start) throws OrmException {
    try {
      source = index.getSource(pred, start, limit);
    } catch (QueryParseException e) {
      // Don't need to show this exception to the user; the only thing that
      // changed about pred was its SortKeyPredicates, and any other QPEs
      // that might happen should have already thrown from the constructor.
      throw new OrmException(e);
    }
    return read();
  }

  @Override
  public Predicate<ChangeData> copy(
      Collection<? extends Predicate<ChangeData>> children) {
    return this;
  }

  @Override
  public boolean match(ChangeData cd) throws OrmException {
    return (source != null && cd.isFromSource(source)) || pred.match(cd);
  }

  @Override
  public int getCost() {
    // Index queries are assumed to be cheaper than any other type of query, so
    // so try to make sure they get picked. Note that pred's cost may be higher
    // because it doesn't know whether it's being used in an index query or not.
    return 1;
  }

  @Override
  public int hashCode() {
    return pred.hashCode();
  }

  @Override
  public boolean equals(Object other) {
    if (other == null || getClass() != other.getClass()) {
      return false;
    }
    IndexedChangeQuery o = (IndexedChangeQuery) other;
    return pred.equals(o.pred)
        && limit == o.limit;
  }

  @Override
  public String toString() {
    return Objects.toStringHelper("index")
        .add("p", pred)
        .add("limit", limit)
        .toString();
  }
}