/*******************************************************************************
 * Copyright (c) 1998, 2012 Oracle and/or its affiliates. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     Oracle - initial API and implementation from Oracle TopLink
 ******************************************************************************/  
package org.eclipse.persistence.testing.tests.unitofwork;

import java.math.BigDecimal;

import java.util.Vector;

import org.eclipse.persistence.expressions.ExpressionBuilder;
import org.eclipse.persistence.queries.ReadObjectQuery;
import org.eclipse.persistence.sessions.Session;
import org.eclipse.persistence.sessions.UnitOfWork;
import org.eclipse.persistence.testing.framework.AutoVerifyTestCase;
import org.eclipse.persistence.testing.framework.TestErrorException;
import org.eclipse.persistence.testing.framework.TestWarningException;


public class ConcurrentRefreshOnCloneTest extends AutoVerifyTestCase {
    // used as monitor for test
    public static ConcurrentAddress lock;

    //stores the cloned copy of the lock object
    public static ConcurrentAddress clone;

    //stores a copy of the original values
    public static ConcurrentAddress original;
    public static boolean cloneWaiting = false;
    public static boolean readerWaiting = false;

    //attribute stores if the thread has waiting to prevent the back clone from entering a wait state
    public static boolean waited = false;

    //used in remote unit of work tests to control when the lock is released
    public static int depth;
    public boolean toClone;

    //session for the threads
    public static Session session;

    //stores the original cache isolation level for this session
    int originalIsolationLevel;

    public ConcurrentRefreshOnCloneTest() {
    }

    public ConcurrentRefreshOnCloneTest(boolean toClone) {
        this.toClone = toClone;
    }

    public void setup() {
        if (getSession().isDistributedSession()) {
            throw new TestWarningException("Test unavailable on Remote UnitOfWork because of timing issues");
        }
        getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
        ConcurrentRefreshOnCloneTest.session = getSession();
        ConcurrentRefreshOnCloneTest.waited = false;
        ConcurrentAddress newAddress = new ConcurrentAddress();
        newAddress.id = new BigDecimal(15);
        newAddress.city = "Meductic";
        newAddress.country = "Canada";
        newAddress.postalCode = "C1C 1C1";
        newAddress.province = "New Brunswick";
        newAddress.street = "St. Jermone";
        UnitOfWork uow = getSession().acquireUnitOfWork();
        uow.registerObject(newAddress);
        uow.commit();
        ConcurrentRefreshOnCloneTest.lock = newAddress;

        this.originalIsolationLevel = getSession().getLogin().getCacheTransactionIsolation();

        getSession().getLogin().setCacheTransactionIsolation(org.eclipse.persistence.sessions.DatasourceLogin.SYNCHRONIZED_READ_ON_WRITE);
    }

    public void test() {
        ConcurrentRefreshOnCloneTest.lock.city = "Some Large City";
        ConcurrentRefreshOnCloneTest.lock.country = "Some Small Country";
        ConcurrentRefreshOnCloneTest.lock.postalCode = "A1A 1A1";
        ConcurrentRefreshOnCloneTest.lock.province = "No Nation";
        ConcurrentRefreshOnCloneTest.lock.street = "No Name";

        ConcurrentRefreshOnCloneTest.original = (ConcurrentAddress)ConcurrentRefreshOnCloneTest.lock.clone();
        Vector primaryKey = new Vector(1);
        primaryKey.add(ConcurrentRefreshOnCloneTest.lock.getId());

        Thread thread1 = null;
        Thread thread2 = null;
        try {
            thread1 = new Thread(new ConcurrentRefreshOnCloneTest(true).runnable());
            //start the thread and wait for the thread to get under way before continueing.
            thread1.start();
            thread2 = new Thread(new ConcurrentRefreshOnCloneTest(false).runnable());
            //start the thread and wait for the thread to get under way before continueing.
            thread2.start();
        } catch (Exception ex) {
            System.out.println("Exception" + ex.toString());
            //just ignore
        }
        try {
            thread1.join();
            thread2.join();
        } catch (Exception ex) {
            //just an inturrupt ignore
        }
        if (getAbstractSession().compareObjectsDontMatch(ConcurrentRefreshOnCloneTest.lock, 
                                                         ConcurrentRefreshOnCloneTest.clone)) {
            if (getAbstractSession().compareObjectsDontMatch(ConcurrentRefreshOnCloneTest.original, 
                                                             ConcurrentRefreshOnCloneTest.clone)) {
                throw new TestErrorException("The test failed to clone the object without data corruption");
            }
        }
    }

    public Runnable runnable() {
        return new Runnable() {
                public void run() {
                    if (ConcurrentRefreshOnCloneTest.this.toClone) {
                        UnitOfWork uow = ConcurrentRefreshOnCloneTest.session.acquireUnitOfWork();
                        ConcurrentRefreshOnCloneTest.clone = 
                                (ConcurrentAddress)uow.registerObject(ConcurrentRefreshOnCloneTest.lock);
                    } else {
                        try {
                            //sleep here to let the register catch up,
                            //can not wait here as the cloning thread may never wait if a read lock is acquired
                            Thread.sleep(5000);
                        } catch (Exception ex) {
                        }
                        ReadObjectQuery query = new ReadObjectQuery(ConcurrentAddress.class);
                        query.setShouldRefreshIdentityMapResult(true);
                        query.setSelectionCriteria(new ExpressionBuilder().get("id").equal(ConcurrentRefreshOnCloneTest.lock.getId()));
                        ConcurrentRefreshOnCloneTest.session.executeQuery(query);
                        try {
                            if (ConcurrentRefreshOnCloneTest.lock != null) {
                                synchronized (ConcurrentRefreshOnCloneTest.lock) {
                                    ConcurrentRefreshOnCloneTest.lock.notifyAll();
                                }
                            }
                        } catch (Exception ex) {
                        }
                    }
                }
            };
    }

    public void reset() {
        UnitOfWork uow = getSession().acquireUnitOfWork();
        uow.deleteObject(ConcurrentRefreshOnCloneTest.original);
        ConcurrentRefreshOnCloneTest.lock = null;
        uow.commit();
        getSession().getIdentityMapAccessor().initializeAllIdentityMaps();
        getSession().getLogin().setCacheTransactionIsolation(this.originalIsolationLevel);
    }
}
