/*
 * Copyright 2005 The Apache Software Foundation.
 * 
 * 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.apache.jdo.test;

import javax.jdo.JDOException;
import javax.jdo.JDOHelper;
import javax.jdo.JDOOptimisticVerificationException;
import javax.jdo.JDOUserException;
import javax.jdo.PersistenceManager;
import javax.jdo.Transaction;

import org.apache.jdo.pc.PCPoint;
import org.apache.jdo.test.util.AbstractTest;
import org.apache.jdo.test.util.JDORITestRunner;

/**
* Tests that we correctly verify instance values during an optimistic
* transaction.  In this test we create instances, and then get their object
* id's.  We then use those object id's to create objects in a second PM.  We
* then modify the instances in the first PM, and commit them.  Then modify the
* values in some of the instances in an optimistic transaction in the second
* PM, and commit: this should fail, and we should get an exception which
* contains two other exceptions, one for each of the instances which failed to
* verify.
*
* @author Dave Bristor
*/
public class Test_Optimistic extends AbstractTest {

    /** */
    public static void main(String args[]) {
        JDORITestRunner.run(Test_Optimistic.class);
    }

    /**
     * Inserts some number of objects in the database
     */
    public void test() {
        insertObjects();
    }

    // Gets an extent of points, and changes them.
    protected void insertObjects() {
        PersistenceManager pm1 = null;
        PersistenceManager pm2 = null; 
        PersistenceManager pm3 = null;
        Transaction tx1 = null;
        Transaction tx2 = null;
        Transaction tx3 = null;
        try {
            pm1 = pmf.getPersistenceManager();
            tx1 = pm1.currentTransaction();
            if (debug) logger.debug("\nINSERT");

            tx1.setOptimistic(false);
            tx1.begin();
            
            PCPoint p1a = new PCPoint(3, 5);
            pm1.makePersistent(p1a);
            PCPoint p1b = new PCPoint(7, 9);
            pm1.makePersistent(p1b);
            PCPoint p1c = new PCPoint(4, 8);
            pm1.makePersistent(p1c);
            
            Object oid_1a = JDOHelper.getObjectId(p1a);
            if (debug) logger.debug("p1a " + p1a + ", oid=" + oid_1a);
            Object oid_1b = JDOHelper.getObjectId(p1b);
            if (debug) logger.debug("p1b " + p1b + ", oid=" + oid_1b);
            Object oid_1c = JDOHelper.getObjectId(p1c);
            if (debug) logger.debug("p1c " + p1c + ", oid=" + oid_1c);

            tx1.commit();
            
            // Start tx2
            pm2 = pmf.getPersistenceManager();
            tx2 = pm2.currentTransaction();
            tx2.setOptimistic(true);
            tx2.begin();
            
            PCPoint p2a = (PCPoint)pm2.getObjectById(oid_1a, true);
            PCPoint p2b = (PCPoint)pm2.getObjectById(oid_1b, true);
            PCPoint p2c = (PCPoint)pm2.getObjectById(oid_1c, true);

            if (debug)
                printValues("p1X made persistent, p2X from getObjectById(getObjectId) technique",
                            p1a, p1b, p1c, p2a, p2b, p2c);
            
            tx1 = pm1.currentTransaction();
            tx1.setOptimistic(false);
            tx1.begin();
            p1a.setX(555);
            p1b.setX(123);
            // p1c.setX(blah blah); // intentionally, we do *not* change p1c
            tx1.commit();
            
            if (debug) 
                printValues("after change in Tx1 to p1X",
                            p1a, p1b, p1c, p2a, p2b, p2c);
            
            p2a.setY(new Integer(7890)); // This should fail to verify
            p2b.setY(new Integer(1212)); // Ditto p2a
            p2c.setY(new Integer(1357)); // This should succeed (but roll back)
            
            if (debug) 
                printValues("after changes in Tx2 to p1a & p1b",
                            p1a, p1b, p1c, p2a, p2b, p2c);
            
            try {
                tx2.commit();
            } catch (JDOException ex) {
                if (ex instanceof JDOOptimisticVerificationException) {
                    JDOOptimisticVerificationException jex =
                        (JDOOptimisticVerificationException)ex;
                    Throwable nested[] = jex.getNestedExceptions();
                    if (nested.length == 2) {                
                        // XXX This might be improved: it *could* be a datastore
                        // exception, but not one which is for the expected verify
                        // failure.
                        if (debug) 
                            logger.debug("In optimistic transaction, caught expected exception");
                    } else {
                        fail("In optimistic transaction caught unexpected exception:" + ex);
                    }
                } else {
                    fail("In optimistic transaction caught unexpected exception:" + ex);
                }
                try {
                    if (tx2.isActive()) {
                        // MBO: is this legal?
                        if (debug) {
                            logger.debug("Transaction tx2 active; rolling back");
                            printValues("before rollback",
                                        p1a, p1b, p1c, p2a, p2b, p2c);
                        }
                        tx2.rollback();
                    } else {
                        if (debug) logger.debug("Transaction tx2 rolled back");
                    }
                } catch (JDOUserException ex2) {
                    // MBO: might not be necessary, see above
                    fail("Can't rollback" + ex2);
                }
            } finally {
                if (debug) printValues("finally", p1a, p1b, p1c, p2a, p2b, p2c);
                assertPCPointEquals("In finally: unexpected value of p1a", 555, 5, p1a);
                assertPCPointEquals("In finally: unexpected value of p1b", 123, 9, p1b);
                assertPCPointEquals("In finally: unexpected value of p1c", 4, 8, p1c);
                assertPCPointEquals("In finally: unexpected value of p2a", 3, 5, p2a);
                assertPCPointEquals("In finally: unexpected value of p2b", 7, 9, p2b);
                assertPCPointEquals("In finally: unexpected value of p2c", 4, 8, p2c);
            }
            
            pm3 = pmf.getPersistenceManager();
            tx3 = pm3.currentTransaction();
            tx3.setOptimistic(false);
            tx3.begin();
            PCPoint p3a = (PCPoint)pm3.getObjectById(oid_1a, false);
            PCPoint p3b = (PCPoint)pm3.getObjectById(oid_1b, false);
            PCPoint p3c = (PCPoint)pm3.getObjectById(oid_1c, false);
            if (debug)
                printValues("values labelled p2X are really p3X in this list",
                            p1a, p1b, p1c, p3a, p3b, p3c);
            assertPCPointEquals("tx3: unexpected value of p1a", 555, 5, p1a);
            assertPCPointEquals("tx3: unexpected value of p1b", 123, 9, p1b);
            assertPCPointEquals("tx3: unexpected value of p1c", 4, 8, p1c);
            assertPCPointEquals("tx3: unexpected value of p3a", 555, 5, p3a);
            assertPCPointEquals("tx3: unexpected value of p3b", 123, 9, p3b);
            assertPCPointEquals("tx3: unexpected value of p3c", 4, 8, p3c);
            tx3.commit();
        }
        finally {
            if (tx3 != null && tx3.isActive())
                tx3.rollback();
            if (pm3 != null && !pm3.isClosed())
                pm3.close();
            if (tx2 != null && tx2.isActive())
                tx2.rollback();
            if (pm2 != null && !pm2.isClosed())
                pm2.close();
            if (tx1 != null && tx1.isActive())
                tx1.rollback();
            if (pm1 != null && !pm1.isClosed())
                pm1.close();
        }
    }
    
    private void printValues(
        String str, PCPoint p1a, PCPoint p1b, PCPoint p1c,
        PCPoint p2a, PCPoint p2b, PCPoint p2c) {

        logger.debug(str);
        logger.debug("p1a: " + p1a);
        logger.debug("p1b: " + p1b);
        logger.debug("p1c: " + p1c);
        logger.debug("p2a: " + p2a);
        logger.debug("p2b: " + p2b);
        logger.debug("p2c: " + p2c);
    }

    private void assertPCPointEquals(String msg, int x, int y, PCPoint actual)
    {
        assertEquals(msg + " field x", x, actual.getX());
        assertEquals(msg + " field y", new Integer(y), actual.getY());
    }
    
}