/**
 * Copyright 2010 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.box.server.persistence.protos;

import com.google.wave.api.Context;
import com.google.wave.api.ProtocolVersion;
import com.google.wave.api.event.EventType;
import com.google.wave.api.robot.Capability;

import junit.framework.TestCase;

import org.waveprotocol.box.server.account.AccountData;
import org.waveprotocol.box.server.account.HumanAccountData;
import org.waveprotocol.box.server.account.HumanAccountDataImpl;
import org.waveprotocol.box.server.account.RobotAccountData;
import org.waveprotocol.box.server.account.RobotAccountDataImpl;
import org.waveprotocol.box.server.authentication.PasswordDigest;
import org.waveprotocol.box.server.persistence.protos.ProtoAccountStoreData.ProtoAccountData;
import org.waveprotocol.box.server.robots.RobotCapabilities;
import org.waveprotocol.wave.model.util.CollectionUtils;
import org.waveprotocol.wave.model.wave.ParticipantId;

import java.util.EnumSet;
import java.util.Map;
/**
 * Testcases for {@link ProtoAccountDataSerializer}
 * 
 * @author tad.glines@gmail.com (Tad Glines)
 */
public class ProtoAccountDataSerializerTest extends TestCase {
  private static final ParticipantId HUMAN_ID = ParticipantId.ofUnsafe("human@example.com");

  private static final ParticipantId ROBOT_ID = ParticipantId.ofUnsafe("robot@example.com");

  private RobotAccountData robotAccount;

  private RobotAccountData robotAccountWithCapabilities;

  private HumanAccountData humanAccount;

  private HumanAccountData humanAccountWithDigest;

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    robotAccount = new RobotAccountDataImpl(ROBOT_ID, "example.com", "secret", null, false);

    Map<EventType, Capability> capabilities = CollectionUtils.newHashMap();
    capabilities.put(
        EventType.WAVELET_BLIP_CREATED, new Capability(EventType.WAVELET_BLIP_CREATED));
    capabilities.put(EventType.DOCUMENT_CHANGED,
        new Capability(EventType.DOCUMENT_CHANGED, CollectionUtils.newArrayList(Context.SIBLINGS)));
    
    capabilities.put(EventType.BLIP_SUBMITTED,
        new Capability(EventType.BLIP_SUBMITTED,
            CollectionUtils.newArrayList(Context.SIBLINGS, Context.PARENT), "blah"));
    
    robotAccountWithCapabilities =
        new RobotAccountDataImpl(ROBOT_ID, "example.com", "secret", new RobotCapabilities(
            capabilities, "FAKEHASH", ProtocolVersion.DEFAULT), true);

    humanAccount = new HumanAccountDataImpl(HUMAN_ID);
    humanAccountWithDigest = new HumanAccountDataImpl(HUMAN_ID,
        new PasswordDigest("password".toCharArray()));
  }

  private boolean compareCapability(Capability c1, Capability c2) {
    if (c1.getEventType() != c2.getEventType() ||
        !c1.getFilter().equals(c2.getFilter())) {
      return false;
    }

    EnumSet<Context> cset1 = EnumSet.copyOf(c1.getContexts());
    EnumSet<Context> cset2 = EnumSet.copyOf(c2.getContexts());
    
    return cset1.equals(cset2);
  }
  
  private boolean compareRobotCapabilities(RobotCapabilities r1, RobotCapabilities r2) {
    if (r1.getProtocolVersion() != r2.getProtocolVersion() ||
        !r1.getCapabilitiesHash().equals(r2.getCapabilitiesHash())) {
      return false;
    }

    Map<EventType, Capability> map1 = r1.getCapabilitiesMap();
    Map<EventType, Capability> map2 = r1.getCapabilitiesMap();
    
    for (EventType eventType : map1.keySet()) {
      Capability c1 = map1.get(eventType);
      Capability c2 = map2.get(eventType);
      if (c2 == null || !compareCapability(c1, c2)) {
        return false;
      }
    }

    for (EventType eventType : map2.keySet()) {
      if (!map1.containsKey(eventType)) {
        return false;
      }
    }
    
    return true;
  }
  
  public final void testHumanAccount() {
    ProtoAccountData data = ProtoAccountDataSerializer.serialize(humanAccount);
    AccountData account = ProtoAccountDataSerializer.deserialize(data);
    assertEquals(humanAccount, account);
  }

  public final void testHumanAccountWithDigest() {
    ProtoAccountData data = ProtoAccountDataSerializer.serialize(humanAccountWithDigest);
    AccountData account = ProtoAccountDataSerializer.deserialize(data);
    assertEquals(humanAccountWithDigest, account);
  }

  public final void testRobotAccount() {
    ProtoAccountData data = ProtoAccountDataSerializer.serialize(robotAccount);
    AccountData account = ProtoAccountDataSerializer.deserialize(data);
    assertEquals(robotAccount, account);
  }

  public final void testRobotAccountWithCapabilities() {
    ProtoAccountData data = ProtoAccountDataSerializer.serialize(robotAccountWithCapabilities);
    AccountData account = ProtoAccountDataSerializer.deserialize(data);
    assertEquals(robotAccountWithCapabilities, account);
  }
}