/**
 * Copyright 2008 Google Inc.
 *
 * 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 org.waveprotocol.wave.concurrencycontrol.common;

import org.waveprotocol.wave.model.operation.OperationPair;
import org.waveprotocol.wave.model.operation.TransformException;
import org.waveprotocol.wave.model.operation.wave.Transform;
import org.waveprotocol.wave.model.operation.wave.WaveletOperation;
import org.waveprotocol.wave.model.util.CollectionUtils;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * Operations sequences representing a client and a server delta.
 *
 * @author zdwang@google.com (David Wang)
 */
public class DeltaPair {
  private final List<WaveletOperation> client;
  private final List<WaveletOperation> server;

  /**
   * Create a delta pair with a client and server op.
   * @param client
   * @param server
   */
  public DeltaPair(Iterable<WaveletOperation> client, Iterable<WaveletOperation> server) {
    this.client = CollectionUtils.newArrayList(client);
    this.server = CollectionUtils.newArrayList(server);
  }

  /**
   * Transforms this pair of deltas to a new pair of deltas.
   * If 2 deltas are the same, they nullify each other.
   *
   * The caller is responsible for setting the version on the result deltas.
   *
   * @return never null
   * @throws TransformException
   */
  public DeltaPair transform() throws TransformException {
    // If 2 deltas are the same, they nullify each other.
    if (areSame(client, server)) {
      List<WaveletOperation> outServer = CollectionUtils.newArrayList();
      // Produce version update ops for the server ops, as version on the server
      // has increased even though nullified on the client.
      Iterator<WaveletOperation> serverOpItr = server.iterator();
      while (serverOpItr.hasNext()) {
        WaveletOperation serverOp = serverOpItr.next();
        outServer.add(serverOp.createVersionUpdateOp(serverOp.getContext().getVersionIncrement(),
            serverOp.getContext().getHashedVersion()));

      }
      return new DeltaPair(Arrays.<WaveletOperation> asList(), outServer);
    }

    List<WaveletOperation> outServer = CollectionUtils.newArrayList();
    List<WaveletOperation> outClient = CollectionUtils.newArrayList(client);

    for (WaveletOperation serverOp : server) {
      WaveletOperation newServerOp = serverOp;
      List<WaveletOperation> tempClientDelta = CollectionUtils.newArrayList();

      for (WaveletOperation clientOp : outClient) {
        OperationPair<WaveletOperation> operationPair =
            Transform.transform(clientOp, newServerOp);
        clientOp = operationPair.clientOp();
        newServerOp = operationPair.serverOp();
        tempClientDelta.add(clientOp);
      }
      outClient = tempClientDelta;
      outServer.add(newServerOp);
    }
    return new DeltaPair(outClient, outServer);
  }

  /**
   * @return Held client delta.
   */
  public List<WaveletOperation> getClient() {
    return client;
  }

  /**
   * @return Held server delta.
   */
  public List<WaveletOperation> getServer() {
    return server;
  }

  /**
   * Checks whether two operation sequences are the same.
   */
  public static boolean areSame(List<WaveletOperation> deltaA, List<WaveletOperation> deltaB) {
    if (deltaA.size() != deltaB.size()) {
      return false;
    }

    for (int i = 0; i < deltaA.size(); ++i) {
      if (!matchOperations(deltaA.get(i), deltaB.get(i))) {
        return false;
      }
    }
    return true;
  }

  /**
   * Compares operations by testing author and actual operation.
   */
  private static boolean matchOperations(WaveletOperation a, WaveletOperation b) {
    return a.getContext().getCreator().equals(b.getContext().getCreator()) &&
           a.equals(b);
  }
}