package com.jboss.datagrid.test.backwardcompatibility;

import java.io.File;
import java.util.HashMap;
import java.util.Map;

import com.jboss.datagrid.test.backwardcompatibility.utils.DeploymentBuilder;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.eviction.EvictionStrategy;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.marshall.exts.MapExternalizer;
import org.jboss.arquillian.container.test.api.Deployer;
import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.container.test.api.OperateOnDeployment;
import org.jboss.arquillian.container.test.api.TargetsContainer;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.arquillian.junit.InSequence;
import org.jboss.arquillian.test.api.ArquillianResource;
import org.jboss.shrinkwrap.api.spec.WebArchive;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.junit.Assert.assertEquals;

/**
 *
 */
@RunWith(Arquillian.class)
public class SingleFileStoreBackwardCompatibilityIT {

    private DefaultCacheManager dfc = null;
    private String cacheName = "testCache";

    private static final String OLD_JDG = "dep1_with_old_jdg";
    private static final String NEW_JDG = "dep2_with_new_jdg";

    private static Map<String, String> storedMap;

    @ArquillianResource
    Deployer deployer;

    @Deployment(name = OLD_JDG, testable = true, managed = false)
    @TargetsContainer("container1")
    public static WebArchive createDeploymentOld() {
        WebArchive jar = DeploymentBuilder.createTestArchiveWithPreviousJDG("test1.war", "previous");
        System.out.println("Content: ===================" + jar.getContent());
        return jar;
    }

    @Deployment(name = NEW_JDG, testable = true, managed = false)
    @TargetsContainer("container2")
    public static WebArchive createDeploymentNew() {
        WebArchive jar = DeploymentBuilder.createTestArchive("test2.war", "current");
        return jar;
    }

    private DefaultCacheManager configureCacheManager(boolean clearCacheStore) throws Exception {
        GlobalConfiguration glob = new GlobalConfigurationBuilder().nonClusteredDefault()
                .globalJmxStatistics().allowDuplicateDomains(true).
                        build();
        ConfigurationBuilder c = new ConfigurationBuilder();
        c.clustering().cacheMode(CacheMode.LOCAL);

        File tmpStore = new File("/tmp/cache/" + cacheName + ".dat");
        if (clearCacheStore && tmpStore.exists()) {
            tmpStore.delete();
        }
        c.persistence().passivation(false).addSingleFileStore().purgeOnStartup(false).location("/tmp/cache/");
        Configuration cnf = c.build();
        DefaultCacheManager manager = new DefaultCacheManager(glob);

        manager.defineConfiguration(cacheName, cnf);
        return manager;
    }

    @Test
    @OperateOnDeployment(OLD_JDG)
    @InSequence(1)
    public void testStoreWithOldJDG() throws Exception {
        deployer.deploy(OLD_JDG);
        dfc = configureCacheManager(true);
        dfc.start();
        Cache<Object, Object> cache = dfc.getCache(cacheName);
        System.out.println("Version: " + cache.getVersion());
        storedMap = new HashMap<String, String>();
        storedMap.put("k", "v");
        cache.put("mapKey", storedMap);
        dfc.stop();
        deployer.undeploy(OLD_JDG);
    }

    @Test
    @OperateOnDeployment(NEW_JDG)
    @InSequence(2)
    public void testReadWithNewJDG() throws Exception {
        deployer.deploy(NEW_JDG);
        dfc = configureCacheManager(false);
        dfc.start();
        Cache<Object, Object> cache = dfc.getCache(cacheName);
        System.out.println("Version: " + cache.getVersion());
        assertEquals(storedMap, cache.get("mapKey"));
        dfc.stop();
        deployer.undeploy(NEW_JDG);
    }

}