/*
 * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
 * agreements. See the NOTICE file distributed with this work for additional information regarding
 * copyright ownership. The ASF licenses this file to You 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.
 */

/*
 * PutAllCallBkRemoteVMDUnitTest.java
 *
 * Created on September 2, 2005, 2:49 PM
 */
package org.apache.geode.cache30;

import static org.apache.geode.test.dunit.LogWriterUtils.getLogWriter;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;

import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import org.junit.Test;

import org.apache.geode.cache.AttributesFactory;
import org.apache.geode.cache.Cache;
import org.apache.geode.cache.CacheException;
import org.apache.geode.cache.CacheFactory;
import org.apache.geode.cache.CacheListener;
import org.apache.geode.cache.CacheWriter;
import org.apache.geode.cache.DataPolicy;
import org.apache.geode.cache.EntryEvent;
import org.apache.geode.cache.Region;
import org.apache.geode.cache.RegionAttributes;
import org.apache.geode.cache.Scope;
import org.apache.geode.cache.util.CacheListenerAdapter;
import org.apache.geode.cache.util.CacheWriterAdapter;
import org.apache.geode.distributed.DistributedSystem;
import org.apache.geode.test.awaitility.GeodeAwaitility;
import org.apache.geode.test.dunit.Host;
import org.apache.geode.test.dunit.LogWriterUtils;
import org.apache.geode.test.dunit.VM;
import org.apache.geode.test.dunit.WaitCriterion;
import org.apache.geode.test.dunit.internal.JUnit4DistributedTestCase;


public class PutAllCallBkRemoteVMDUnitTest extends JUnit4DistributedTestCase {

  static volatile Cache cache;
  static Properties props = new Properties();
  static Properties propsWork = new Properties();
  static volatile DistributedSystem ds = null;
  static volatile Region region;
  static volatile Region paperRegion;
  static boolean afterCreate = false;
  static boolean afterUpdate = false;
  static int putAllcounter = 0;
  static int afterUpdateputAllcounter = 0;
  static boolean beforeCreate = false;
  static boolean beforeUpdate = false;
  static int forCreate = 0;
  static int forUpdate = 0;
  static int beforeCreateputAllcounter = 0;
  static int beforeUpdateputAllcounter = 0;
  static boolean notified = false;

  @Override
  public final void postSetUp() throws Exception {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    vm0.invoke(PutAllCallBkRemoteVMDUnitTest::createCacheForVM0);
    vm1.invoke(PutAllCallBkRemoteVMDUnitTest::createCacheForVM1);
    LogWriterUtils.getLogWriter().info("Cache created successfully");
  }

  @Override
  public final void preTearDown() throws Exception {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);
    vm0.invoke(PutAllCallBkRemoteVMDUnitTest::closeCache);
    vm1.invoke(PutAllCallBkRemoteVMDUnitTest::closeCache);
  }

  public static synchronized void createCacheForVM0() {
    try {
      ds = (new PutAllCallBkRemoteVMDUnitTest()).getSystem(props);
      cache = CacheFactory.create(ds);
      AttributesFactory factory = new AttributesFactory();
      factory.setDataPolicy(DataPolicy.REPLICATE);
      factory.setScope(Scope.DISTRIBUTED_ACK);
      RegionAttributes attr1 = factory.create();
      paperRegion = cache.createRegion("paper", attr1);
      RegionAttributes attr = factory.create();
      region = cache.createRegion("map", attr);

    } catch (CacheException ex) {
      throw new RuntimeException("vm0 cache creation exception", ex);
    }
  }

  public static void createCacheForVM1() {
    try {
      CacheListener aListener = new AfterCreateCallback();
      CacheWriter aWriter = new BeforeCreateCallback();

      ds = (new PutAllCallBkRemoteVMDUnitTest()).getSystem(props);
      cache = CacheFactory.create(ds);
      AttributesFactory factory = new AttributesFactory();
      factory.setDataPolicy(DataPolicy.REPLICATE);
      factory.setScope(Scope.DISTRIBUTED_ACK);
      RegionAttributes attr1 = factory.create();
      paperRegion = cache.createRegion("paper", attr1);
      factory.setCacheWriter(aWriter);
      factory.addCacheListener(aListener);
      RegionAttributes attr = factory.create();
      region = cache.createRegion("map", attr);
    } catch (CacheException ex) {
      throw new RuntimeException("vm1 cache creation exception", ex);
    }
  }


  public static synchronized void closeCache() {
    paperRegion = null;
    region = null;
    if (cache != null) {
      cache.close();
      cache = null;
    }
    if (ds != null) {
      ds.disconnect();
      ds = null;
    }
  }

  // test methods

  @Test
  public void testputAllRemoteVM() {

    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);

    //////////////// testing create call backs//////////////

    vm0.invoke(new CacheSerializableRunnable("put entries") {
      @Override
      public void run2() throws CacheException {
        Map m = new HashMap();
        paperRegion.put("callbackCame", "false");
        try {
          for (int i = 1; i < 21; i++) {
            m.put(i, java.lang.Integer.toString(i));
          }
          region.putAll(m);

        } catch (Exception ex) {
          throw new RuntimeException("exception putting entries", ex);
        }
        getLogWriter()
            .info("****************paperRegion.get(afterCreate)***************"
                + paperRegion.get("afterCreate"));

        WaitCriterion ev = new WaitCriterion() {
          @Override
          public boolean done() {
            int size = region.size();
            if (size != (Integer) paperRegion.get("afterCreate") - 1) {
              return false;
            }
            return size == (Integer) paperRegion.get("beforeCreate") - 1;
          }

          @Override
          public String description() {
            return "Waiting for event";
          }
        };
        GeodeAwaitility.await().untilAsserted(ev);
      }
    });


    vm1.invoke(new CacheSerializableRunnable("validate callbacks") {
      @Override
      public void run2() throws CacheException {
        if (!notified) {
          try {
            synchronized (PutAllCallBkRemoteVMDUnitTest.class) {
              wait();
            }
          } catch (Exception ignored) {

          }
        }
        if (!paperRegion.get("callbackCame").equals("true")) {
          fail("Failed in aftercreate call back :: PutAllCallBkRemoteVMDUnitTest ");
        }

      }
    });


    // to test afterUpdate

  }

  @Test
  public void testPutAllAfterUpdateCallbacks() {
    Host host = Host.getHost(0);
    VM vm0 = host.getVM(0);
    VM vm1 = host.getVM(1);

    vm0.invoke(new CacheSerializableRunnable("put and then update") {
      @Override
      public void run2() throws CacheException {
        paperRegion.put("callbackCame", "false");
        // to invoke afterUpdate we should make sure that entries are already present
        for (int i = 0; i < 5; i++) {
          region.put(i, "region" + i);
        }

        Map m = new HashMap();
        for (int i = 0; i < 5; i++) {
          m.put(i, "map" + i);
        }

        region.putAll(m);

        // try{
        // Thread.sleep(3000);
        // }catch(InterruptedException ex){
        // //
        // }

        assertEquals(region.size(), (Integer) paperRegion.get("beforeUpdate") - 1);
        assertEquals(region.size(), (Integer) paperRegion.get("afterUpdate") - 1);
      }
    });

    vm1.invoke(new CacheSerializableRunnable("validate callbacks") {
      @Override
      public void run2() throws CacheException {

        if (!notified) {
          try {
            synchronized (PutAllCallBkRemoteVMDUnitTest.class) {
              wait();
            }
          } catch (Exception ignored) {

          }
        }

        if (!paperRegion.get("callbackCame").equals("true")) {
          fail("Failed in afterUpdate call back :: PutAllCallBkRemoteVMDUnitTest");
        }

      }
    });

  }// end of test case1


  public static Object putMethod(Object ob) {
    Object obj = null;
    try {
      if (ob != null) {
        String str = "first";
        obj = region.put(ob, str);
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      fail("Failed while region.put");
    }
    return obj;
  }// end of putMethod

  public static void putAllMethod() {
    Map m = new HashMap();
    int i = 5, cntr = 0;
    try {
      while (cntr < 20) {
        m.put(i, "map" + i);
        i++;
        cntr++;
      }

      region.putAll(m);

    } catch (Exception ex) {
      ex.printStackTrace();
      fail("Failed while region.putAll");
    }
  }// end of putAllMethod


  public static Object getMethod(Object ob) {
    Object obj = null;
    try {
      obj = region.get(ob);
    } catch (Exception ex) {
      fail("Failed while region.get");
    }
    return obj;
  }


  public static int sizeMethod() {
    int i = 0;
    try {
      i = region.size();
    } catch (Exception ex) {
      fail("Failed while region.size");
    }
    return i;
  }

  public static void clearMethod() {
    try {
      region.clear();
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }

  static class AfterCreateCallback extends CacheListenerAdapter {
    @Override
    public void afterCreate(EntryEvent event) {
      paperRegion.put("callbackCame", "true");
      Integer counter = (Integer) paperRegion.get("afterCreate");
      if (counter == null) {
        counter = 1;
      }
      paperRegion.put("afterCreate", counter + 1);

      LogWriterUtils.getLogWriter().info("In afterCreate" + putAllcounter);
      if (putAllcounter == forCreate) {
        LogWriterUtils.getLogWriter().info("performingtrue");
        afterCreate = true;
      }
      try {
        synchronized (PutAllCallBkRemoteVMDUnitTest.class) {
          notify();
        }
      } catch (Exception ignored) {

      }
      notified = true;
      LogWriterUtils.getLogWriter().info(
          "*******afterCreate***** Key :" + event.getKey() + " Value :" + event.getNewValue());
    }

    @Override
    public void afterUpdate(EntryEvent event) {
      paperRegion.put("callbackCame", "true");
      Integer counter = (Integer) paperRegion.get("afterUpdate");
      if (counter == null) {
        counter = 1;
      }
      paperRegion.put("afterUpdate", counter + 1);
      LogWriterUtils.getLogWriter().info("In afterUpdate" + afterUpdateputAllcounter);
      if (afterUpdateputAllcounter == forUpdate) {
        LogWriterUtils.getLogWriter().info("performingtrue afterUpdate");
        afterUpdate = true;
      }
      try {
        synchronized (PutAllCallBkRemoteVMDUnitTest.class) {
          notify();
        }
      } catch (Exception ignored) {

      }

      notified = true;

      LogWriterUtils.getLogWriter().info(
          "*******afterUpdate***** Key :" + event.getKey() + " Value :" + event.getNewValue());

    }
  }
  static class BeforeCreateCallback extends CacheWriterAdapter {
    // static class BeforeCreateCallback extends CapacityControllerAdapter {
    @Override
    public void beforeCreate(EntryEvent event) {
      Integer counter = (Integer) paperRegion.get("beforeCreate");
      if (counter == null) {
        counter = 1;
      }
      paperRegion.put("beforeCreate", counter + 1);
      LogWriterUtils.getLogWriter().info("*******BeforeCreate***** event=" + event);
    }

    @Override
    public void beforeUpdate(EntryEvent event) {
      Integer counter = (Integer) paperRegion.get("beforeUpdate");
      if (counter == null) {
        counter = 1;
      }
      paperRegion.put("beforeUpdate", counter + 1);
      LogWriterUtils.getLogWriter().info("In beforeUpdate" + beforeUpdateputAllcounter);
      LogWriterUtils.getLogWriter().info("*******BeforeUpdate***** event=" + event);
    }
  }
}// end of test class