package org.litesoft.gae.datastoreservice;

import java.util.ConcurrentModificationException;

import junit.framework.TestCase;
import junit.framework.TestSuite;

import com.google.appengine.api.datastore.DatastoreService;
import com.google.appengine.api.datastore.DatastoreServiceConfig;
import com.google.appengine.api.datastore.DatastoreServiceFactory;
import com.google.appengine.api.datastore.Entity;
import com.google.appengine.api.datastore.EntityNotFoundException;
import com.google.appengine.api.datastore.ImplicitTransactionManagementPolicy;
import com.google.appengine.api.datastore.Key;
import com.google.appengine.api.datastore.KeyFactory;
import com.google.appengine.api.datastore.Transaction;
import com.google.appengine.api.datastore.ReadPolicy.Consistency;
import com.google.appengine.tools.development.testing.LocalDatastoreServiceTestConfig;
import com.google.appengine.tools.development.testing.LocalServiceTestHelper;

public class DatastoreServiceTest extends TestCase {
	private final LocalServiceTestHelper mHelper = new LocalServiceTestHelper(
			new LocalDatastoreServiceTestConfig());

	public static TestSuite suite() {
		return new TestSuite(DatastoreServiceTest.class);
	}

	public DatastoreServiceTest(String name) {
		super(name);
	}

	public static void main(String[] args) {
		junit.textui.TestRunner.run(suite());
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		mHelper.setUp();
		mConfig = DatastoreServiceConfig.Builder.withDefaults() // Deadline=null,
				// ImplicitTransactionManagementPolicy=NONE,
				// ReadPolicy.Consistency=STRONG
				.deadline(5); // Deadline=5 secs
		mDatastoreService = DatastoreServiceFactory
				.getDatastoreService(mConfig);
		mGOD_Apollo = KeyFactory.createKey("GODS", "Apollo");
		mGOD_Venus = KeyFactory.createKey("GODS", "Venus");

	}

	@Override
	public void tearDown() {
		mHelper.tearDown();
	}

	private DatastoreServiceConfig mConfig;
	private DatastoreService mDatastoreService;
	private Key mGOD_Apollo, mGOD_Venus;

	private Entity createEntity(Key pGOD, String pName) {
		Entity zEntity = new Entity("TheFlintstones", pName, pGOD);
		zEntity.setUnindexedProperty("Version", 1L);

		zEntity.setProperty("Name", pName);
		zEntity.setUnindexedProperty("Children", 0L);
		return zEntity;
	}

	private void inc(Entity pEntity, String pProperty) {
		Long zLong = (Long) pEntity.getProperty(pProperty);
		pEntity.setUnindexedProperty(pProperty, zLong + 1);
	}

	private Entity updateChildren(Entity pEntity) {
		inc(pEntity, "Version");
		inc(pEntity, "Children");
		return pEntity;
	}

	public void test_DataStoreConfig() throws Exception {
		assertEquals(5.0d, mConfig.getDeadline(), 0.0001);
		assertEquals(ImplicitTransactionManagementPolicy.NONE, mConfig
				.getImplicitTransactionManagementPolicy());
		assertEquals(Consistency.STRONG, mConfig.getReadPolicy()
				.getConsistency());
	}

	public void test_NonConflictingOverlapingTransactionsNew() throws Exception {
		Transaction zApolloTransaction = mDatastoreService.beginTransaction();
		Transaction zVenusTransaction = mDatastoreService.beginTransaction();

		Entity zEntityFred = createEntity(mGOD_Apollo, "Fred");
		mDatastoreService.put(zApolloTransaction, zEntityFred);
		Entity zEntityWilma = createEntity(mGOD_Venus, "Wilma");
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		Entity zEntityBarney = createEntity(mGOD_Apollo, "Barney");
		mDatastoreService.put(zApolloTransaction, zEntityBarney);
		Entity zEntityBetty = createEntity(mGOD_Venus, "Betty");
		mDatastoreService.put(zVenusTransaction, zEntityBetty);

		zApolloTransaction.commit();
		zVenusTransaction.commit();

		readAndValidate(null, zEntityFred, "Fred", 1, 0);
		readAndValidate(null, zEntityWilma, "Wilma", 1, 0);

		readAndValidate(null, zEntityBarney, "Barney", 1, 0);
		readAndValidate(null, zEntityBetty, "Betty", 1, 0);
	}

	public void test_TransactionReadMultiGOD() throws Exception {
		Transaction zApolloTransaction = mDatastoreService.beginTransaction();
		Transaction zVenusTransaction = mDatastoreService.beginTransaction();

		Entity zEntityFred = createEntity(mGOD_Apollo, "Fred");
		mDatastoreService.put(zApolloTransaction, zEntityFred);
		Entity zEntityWilma = createEntity(mGOD_Venus, "Wilma");
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		zApolloTransaction.commit();
		zVenusTransaction.commit();

		Transaction zTransaction = mDatastoreService.beginTransaction();
		mDatastoreService.get(zTransaction, zEntityFred.getKey()); // will
		// succeed!
		try {
			mDatastoreService.get(zTransaction, zEntityWilma.getKey()); // will
			// Fail!
			fail("Fred & Wilma - Did NOT Fail with different GODS (Entity Groups)");
		} catch (IllegalArgumentException expected) {
			String zMessage = expected.getMessage();
			assertTrue(
					zMessage,
					zMessage
							.startsWith("can't operate on multiple entity groups in a single transaction."));
		}
		zTransaction.rollback();
	}

	public void test_TransactionUpdate() throws Exception {
		Transaction zApolloTransaction = mDatastoreService.beginTransaction();
		Transaction zVenusTransaction = mDatastoreService.beginTransaction();

		Entity zEntityFred = createEntity(mGOD_Apollo, "Fred");
		mDatastoreService.put(zApolloTransaction, zEntityFred);
		Entity zEntityWilma = createEntity(mGOD_Venus, "Wilma");
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		Entity zEntityBarney = createEntity(mGOD_Apollo, "Barney");
		mDatastoreService.put(zApolloTransaction, zEntityBarney);
		Entity zEntityBetty = createEntity(mGOD_Venus, "Betty");
		mDatastoreService.put(zVenusTransaction, zEntityBetty);

		zApolloTransaction.commit();
		zVenusTransaction.commit();

		zVenusTransaction = mDatastoreService.beginTransaction();

		zEntityWilma = updateChildren(readAndValidate(zVenusTransaction,
				zEntityWilma, "Wilma", 1, 0));
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		Entity zEntityPebbles = createEntity(mGOD_Venus, "Pebbles");
		mDatastoreService.put(zVenusTransaction, zEntityPebbles);

		// Can't Update Fred!

		zVenusTransaction.commit();

		zApolloTransaction = mDatastoreService.beginTransaction();

		zEntityBarney = updateChildren(readAndValidate(zApolloTransaction,
				zEntityBarney, "Barney", 1, 0));
		mDatastoreService.put(zApolloTransaction, zEntityBarney);

		Entity zEntityBammBamm = createEntity(mGOD_Apollo, "BammBamm");
		mDatastoreService.put(zApolloTransaction, zEntityBammBamm);

		// Can't Update Betty!

		zApolloTransaction.commit();

		readAndValidate(null, zEntityFred, "Fred", 1, 0);
		readAndValidate(null, zEntityWilma, "Wilma", 2, 1);
		readAndValidate(null, zEntityPebbles, "Pebbles", 1, 0);

		readAndValidate(null, zEntityBarney, "Barney", 2, 1);
		readAndValidate(null, zEntityBetty, "Betty", 1, 0);
		readAndValidate(null, zEntityBammBamm, "BammBamm", 1, 0);
	}

	public void test_NonConflictingOverlapingTransactionsUpdate()
			throws Exception {
		Transaction zApolloTransaction = mDatastoreService.beginTransaction();
		Transaction zVenusTransaction = mDatastoreService.beginTransaction();

		Entity zEntityFred = createEntity(mGOD_Apollo, "Fred");
		mDatastoreService.put(zApolloTransaction, zEntityFred);
		Entity zEntityWilma = createEntity(mGOD_Venus, "Wilma");
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		zApolloTransaction.commit();
		zVenusTransaction.commit();

		zApolloTransaction = mDatastoreService.beginTransaction();
		zVenusTransaction = mDatastoreService.beginTransaction();

		zEntityWilma = updateChildren(readAndValidate(zVenusTransaction,
				zEntityWilma, "Wilma", 1, 0));
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		Entity zEntityPebbles = createEntity(mGOD_Venus, "Pebbles");
		mDatastoreService.put(zVenusTransaction, zEntityPebbles);

		zEntityFred = updateChildren(readAndValidate(zApolloTransaction,
				zEntityFred, "Fred", 1, 0));
		mDatastoreService.put(zApolloTransaction, zEntityFred);

		zApolloTransaction.commit();
		zVenusTransaction.commit();

		readAndValidate(null, zEntityFred, "Fred", 2, 1);
		readAndValidate(null, zEntityWilma, "Wilma", 2, 1);

		readAndValidate(null, zEntityPebbles, "Pebbles", 1, 0);
	}

	public void test_ConflictingOverlapingTransactionsUpdate() throws Exception {
		Transaction zVenusTransaction = mDatastoreService.beginTransaction();

		Entity zEntityWilma = createEntity(mGOD_Venus, "Wilma");
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		zVenusTransaction.commit();

		zVenusTransaction = mDatastoreService.beginTransaction();

		zEntityWilma = updateChildren(readAndValidate(zVenusTransaction,
				zEntityWilma, "Wilma", 1, 0));
		mDatastoreService.put(zVenusTransaction, zEntityWilma);

		Entity zEntityPebbles = createEntity(mGOD_Venus, "Pebbles");
		mDatastoreService.put(zVenusTransaction, zEntityPebbles);

		Transaction zVenus2Transaction = mDatastoreService.beginTransaction();

		Entity zEntityWilma2 = updateChildren(readAndValidate2(
				zVenus2Transaction, zEntityWilma, "Wilma", 1, 0));
		mDatastoreService.put(zVenus2Transaction, zEntityWilma2);

		zVenusTransaction.commit();

		try {
			zVenus2Transaction.commit();
			fail("Two Transaction Wilma Update - Did NOT Fail");
		} catch (ConcurrentModificationException expected) {
			String zMessage = expected.getMessage();
			assertTrue(
					zMessage,
					zMessage
							.startsWith("too much contention on these datastore entities. please try again."));
		}
	}

	private Entity readAndValidate(Transaction pTransaction, Entity pEntity,
			String pName, long pCurrentVersion, long pCurrentChildren)
			throws EntityNotFoundException {
		assertEquals("Current Entity Version", pCurrentVersion, pEntity
				.getProperty("Version"));
		assertEquals("Current Entity Name", pName, pEntity.getProperty("Name"));
		assertEquals("Current Entity Children", pCurrentChildren, pEntity
				.getProperty("Children"));

		return readAndValidate2(pTransaction, pEntity, pName, pCurrentVersion,
				pCurrentChildren);
	}

	private Entity readAndValidate2(Transaction pTransaction, Entity pEntity,
			String pName, long pCurrentVersion, long pCurrentChildren)
			throws EntityNotFoundException {
		Key zKey = pEntity.getKey();
		Entity zEntity = mDatastoreService.get(pTransaction, zKey);

		if (pTransaction == null) {
			Object zVersion = zEntity.getProperty("Version");
			assertNotNull("Read Entity Version", zVersion);
			if (!zVersion.equals(pCurrentVersion)) {
				Transaction zTransaction = mDatastoreService.beginTransaction();
				zEntity = mDatastoreService.get(zTransaction, zKey);
				zTransaction.rollback();
			}
		}

		assertEquals("Read Entity Version", pCurrentVersion, zEntity
				.getProperty("Version"));
		assertEquals("Read Entity Name", pName, zEntity.getProperty("Name"));
		assertEquals("Read Entity Children", pCurrentChildren, zEntity
				.getProperty("Children"));

		return zEntity;
	}
}