/*
 * TestPersistentMaps.java
 *
 * Created on October 13, 2006, 1:54 PM
 *
 * To change this template, choose Tools | Template Manager
 * and open the template in the editor.
 */

/*
 * 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.
 */
package org.apache.openjpa.persistence.kernel;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.openjpa.persistence.Extent;
import org.apache.openjpa.persistence.OpenJPAEntityManager;
import org.apache.openjpa.persistence.OpenJPAQuery;
import org.apache.openjpa.persistence.kernel.common.apps.MapElementPC;
import org.apache.openjpa.persistence.kernel.common.apps.MapElementPCChild;
import org.apache.openjpa.persistence.kernel.common.apps.PersistentMapHolder;

public class TestPersistentMaps extends BaseKernelTest {

    private static final String JDOQL = "javax.jdo.query.JDOQL";

    /**
     * Creates a new instance of TestPersistentMaps
     */
    public TestPersistentMaps() {
    }

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

    @Override
    public void setUp() {
        deleteAll(PersistentMapHolder.class);
        OpenJPAEntityManager pm = getPM();
        startTx(pm);

        pm.persist(new PersistentMapHolder());

        endTx(pm);
        endEm(pm);
    }

    private PersistentMapHolder getHolder(OpenJPAEntityManager pm) {
        Extent e = pm.createExtent(PersistentMapHolder.class, true);
        assertSize(1, ((Collection) e.list()));
        return (PersistentMapHolder) e.iterator().next();
    }

    private Object keyInstance(Class type) throws Exception {
        if (type.getName().equals(String.class.getName()))
            return randomString();
        else
            return type.newInstance();
    }

    private void testMap(int num, String name, Class keyClass, Class valueClass)
        throws Exception {
        OpenJPAEntityManager srcpm = getPM(true, true);
        startTx(srcpm);

        PersistentMapHolder holder = getHolder(srcpm);
        Map map = holder.getNamedMap(name);
        Map internalMap = new HashMap();

        for (int i = 0; i < num; i++) {
            Object key = keyInstance(keyClass);
            Object value = keyInstance(valueClass);
            map.put(key, value);
            internalMap.put(key, value);

            assertEquals(map.get(key), internalMap.get(key));
        }
        endTx(srcpm);

        OpenJPAEntityManager pm = getPM();
        startTx(pm);
//        holder = getHolder(pm);
        map = holder.getNamedMap(name);
        for (Object k : internalMap.keySet()) {
            assertEquals(map.get(k), internalMap.get(k));
        }
        endTx(pm);
        endEm(pm);

        String selectWhere =
            "select from " + PersistentMapHolder.class.getName() + " where ";

        pm = getPM();
        startTx(pm);
        for (Object param : internalMap.keySet()) {

            if (pm.isPersistent(param))
                param = pm.find(param.getClass(), pm.getObjectId(param));

            Object val = internalMap.get(param);
            if (pm.isPersistent(val))
                val = pm.find(val.getClass(), pm.getObjectId(val));

            OpenJPAQuery q;

            q = pm.createQuery(JDOQL,
                    selectWhere + name + ".containsKey(:param)");
            q.setParameter("param", param);
            assertSize(1, q.getResultList());

            q = pm.createQuery(JDOQL,
                    selectWhere + name + ".containsValue(:value)");
            q.setParameter("value", val);
            assertSize(1, q.getResultList());

            q = pm.createQuery(JDOQL, selectWhere + name + ".containsValue(" +
                    name + ".get(:param))");
            q.setParameter("param", param);
            assertSize(1, q.getResultList());

            q = pm.createQuery(JDOQL,
                    selectWhere + name + ".get(:param) != null");
            q.setParameter("param", param);
            assertSize(1, q.getResultList());

            q = pm.createQuery(JDOQL,
                    selectWhere + name + ".get(:param) == :value");
            q.setParameter("param", param);
            q.setParameter("value", val);
            assertSize(1, q.getResultList());

            q = pm.createQuery(JDOQL,
                    selectWhere + name + ".get(:param) != :value");
            q.setParameter("param", param);
            q.setParameter("value", val);
            assertSize(0, q.getResultList());
        }
        endTx(pm);
        endEm(pm);

        pm = getPM();
        startTx(pm);
        for (Object param : internalMap.keySet()) {
            if (pm.isPersistent(param))
                param = pm.find(param.getClass(), pm.getObjectId(param));

            List getQueries = new ArrayList(Arrays.asList(new String[]{
                    selectWhere + name + ".get(:param) != null",
                    selectWhere + name + ".get(:param) == " + name + ".get(:param)",
                    selectWhere + "!(" + name + ".get(:param) == null)",
                    selectWhere + "!(" + name + ".get(:param) != " + name +
                            ".get(:param))",
            }));

            for (Object getQuery : getQueries) {
                String query = (String) getQuery;
                if (valueClass == String.class)
                    query += " order by " + name + ".get(:param) desc";
                OpenJPAQuery q = pm.createQuery(JDOQL, query);
                q.setParameter("param", param);
                assertSize(1, q.getResultList());
            }
        }
        endTx(pm);
        endEm(pm);

        endEm(srcpm);
    }

    public void testPCKeyStringValue()
        throws Exception {
        testMap(5, "testPCKeyStringValue",
            MapElementPC.class, String.class);
    }

    public void testStringKeyPCValue()
        throws Exception {
        testMap(6, "testStringKeyPCValue",
            String.class, MapElementPC.class);
    }

    public void testPCKeyPCValue()
        throws Exception {
        testMap(7, "testPCKeyPCValue",
            MapElementPC.class, MapElementPC.class);
    }

    public void testPCSubKeyStringValue()
        throws Exception {
        testMap(8, "testPCSubKeyStringValue",
            MapElementPCChild.class, String.class);
    }

    public void testStringKeyPCSubValue()
        throws Exception {
        testMap(9, "testStringKeyPCSubValue",
            String.class, MapElementPCChild.class);
    }

    public void testPCSubKeyPCValue()
        throws Exception {
        testMap(10, "testPCSubKeyPCValue",
            MapElementPCChild.class, MapElementPC.class);
    }

    public void testPCSubKeyPCSubValue()
        throws Exception {
        testMap(11, "testPCSubKeyPCSubValue",
            MapElementPCChild.class, MapElementPCChild.class);
    }

    public void testPCKeyPCSubValue()
        throws Exception {
        testMap(12, "testPCKeyPCSubValue",
            MapElementPC.class, MapElementPCChild.class);
    }

    public void testPCIntfKeyStringValue()
        throws Exception {
        testMap(13, "testPCIntfKeyStringValue",
            MapElementPC.class, String.class);
    }

    public void testStringKeyPCIntfValue()
        throws Exception {
        testMap(14, "testStringKeyPCIntfValue",
            String.class, MapElementPC.class);
    }

    public void testPCIntfKeyPCValue()
        throws Exception {
        testMap(15, "testPCIntfKeyPCValue",
            MapElementPC.class, MapElementPC.class);
    }

    /**
     * Test querying maps when there are multiple holder instances that
     * have maps with the same key.
     */
    public void testQueryMultipleMaps() throws Exception {
        deleteAll(PersistentMapHolder.class);

        String mapName = "testStringKeyPCValue";

        String[] mapNames = new String[]{
            "testPCKeyStringValue",
            // "testStringKeyPCValue",
            "testPCKeyPCValue",
            "testPCSubKeyStringValue",
            "testStringKeyPCSubValue",
            "testPCSubKeyPCValue",
            "testPCSubKeyPCSubValue",
            "testPCKeyPCSubValue",
            "testPCIntfKeyStringValue",
            "testStringKeyPCIntfValue",
            "testPCIntfKeyPCValue",
        };

        OpenJPAEntityManager pm;

        pm = getPM();
        startTx(pm);

        MapElementPC pc = new MapElementPC();
        pc.setElementData("foo");

        int max = 5;

        for (int i = 0; i < max; i++) {
            PersistentMapHolder holder = new PersistentMapHolder();
            for (int j = 0; j < i; j++) {
                holder.getNamedMap(mapName).put("key" + j, pc);
            }
            pm.persist(holder);
        }

        endTx(pm);
        endEm(pm);

        pm = getPM();
        pc = (MapElementPC) pm.find(MapElementPC.class, pm.getObjectId(pc));
        for (int i = 0; i < max; i++) {
            OpenJPAQuery q;

            String key = "key" + i;
            String selectWhere = "select from " +
                PersistentMapHolder.class.getName() + " where ";
            q = pm.createQuery(JDOQL,
                selectWhere + mapName + ".containsKey(:key)");
            q.setParameter("key", key);
            assertSize(max - i - 1, q.getResultList());

            q = pm.createQuery(JDOQL,
                selectWhere + mapName + ".get(:key) == :val");
            q.setParameter("key", key);
            q.setParameter("val", pc);
            assertSize(max - i - 1, q.getResultList());

            q = pm.createQuery(JDOQL,
                selectWhere + "testPCKeyStringValue.isEmpty() && "
                    + mapName + ".get(:key) == :val");
            q.setParameter("key", key);
            q.setParameter("val", pc);
            assertSize(max - i - 1, q.getResultList());

            // now try to execute queries against multiple other
            // map instances, so we can make sure the joins are robust
            for (int j = 0; j < mapNames.length; j++) {
                StringBuilder query = new StringBuilder(selectWhere);

                for (int k = 0; k < j; k++) {
                    query.append(mapNames[k] + ".isEmpty() && ");
                }

                q = pm.createQuery(JDOQL,
                    query + mapName + ".get(:key) == :val");
                q.setParameter("key", key);
                q.setParameter("val", pc);
                assertSize(max - i - 1, q.getResultList());
            }
        }
        endEm(pm);
    }
}
