/*******************************************************************************
 * Copyright (c) 2005, 2009 SAP. 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:
 *     SAP - initial API and implementation
 ******************************************************************************/

package org.eclipse.persistence.testing.tests.wdf.jpa1.relation;

import static junit.framework.Assert.assertTrue;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Set;

import javax.persistence.Cache;
import javax.persistence.EntityManager;

import org.eclipse.persistence.testing.framework.wdf.Bugzilla;
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment;
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Bicycle;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.CostCenter;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Cubicle;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.CubiclePrimaryKeyClass;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.MotorVehicle;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Project;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.TravelProfile;
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Vehicle;
import org.eclipse.persistence.testing.tests.wdf.jpa1.JPA1Base;
import org.junit.Test;

/**
 * Testing relations in combination with object cache. Test cases generated by all-pairs testing tool: <li>ToManyFK, eager,
 * owning side right, cacheable both: testCostCenterEmployee</li> <li>ToOneFK, lazy, owning side left, cacheable right:
 * testMotorVehicleEmployee</li> <li>ToOneFK, eager, owning side right, cacheable both: testCubicleEmployee</li> <li>
 * ToManyJoinTable, eager, owning side left, cacheable right: testBicycleEmployee</li> <li>ToManyJoinTable, lazy, owning side
 * left, cacheable both: testEmployeeProject</li> <li>ToManyFK, lazy, owning side right, cacheable right: n.a.</li> <li>
 * ToManyJoinTable, lazy, owning side right, cacheable right: testTravelProfileVehicle</li>
 * 
 * 
 * 
 * <li>ToManyJoinTable, lazy, owning side right, cacheable both: testProjectEmployee</li> <li>ToManyJoinTable, lazy, owning side
 * left, cacheable left: testEmployeePatent</li> <li>ToOneFK, eager, owning side left, cacheable left: testEmployeeTravelProfile
 * </li> <li>ToManyFK, eager, owning side right, cacheable right</li> </ul>
 */
public class TestRelationshipsWithCache extends JPA1Base {

    /**
     * Test case: CostCenter.employees
     * <p>
     * Relationship mapping: ToManyFK, FetchType: eager, owning side: right, cacheable: both
     */
    @Test
    @Bugzilla(bugid=309681)
    public void testCostCenterEmployee() {
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();

        int costCenterId = 1;
        CostCenter costCenter = new CostCenter(1, "lotsOfMoney");
        int employeeId1 = 1;
        int employeeId2 = 2;
        Employee employee1 = new Employee(employeeId1, "very", "expensive", null);
        Employee employee2 = new Employee(employeeId2, "even", "moreExpensive", null);
        costCenter.addEmployee(employee1);
        costCenter.addEmployee(employee2);
        employee1.setCostCenter(costCenter);
        employee2.setCostCenter(costCenter);
        try {
            env.beginTransaction(em);
            em.persist(costCenter);
            em.persist(employee1);
            em.persist(employee2);
            env.commitTransactionAndClear(em);

            em.find(CostCenter.class, costCenterId); // eager loading of Employees
            assertTrue(cache.contains(CostCenter.class, costCenterId));
            assertTrue(cache.contains(Employee.class, employeeId1));
            assertTrue(cache.contains(Employee.class, employeeId2));

            env.beginTransaction(em);
            costCenter = em.find(CostCenter.class, costCenterId);
            employee1 = em.find(Employee.class, employeeId1);
            employee2 = em.find(Employee.class, employeeId2);
            List<Employee> foundEmployees = costCenter.getEmployees();
            assertTrue(foundEmployees != null);
            assertTrue("wrong number of riders: " + foundEmployees.size(), foundEmployees.size() == 2);
            if (foundEmployees.get(0).getId() == employeeId1) {
                assertTrue("wrong rider: " + foundEmployees.get(1).getId(), foundEmployees.get(1).getId() == employeeId2);
            } else {
                assertTrue("wrong rider: " + foundEmployees.get(0).getId(), foundEmployees.get(0).getId() == employeeId2);
                assertTrue("wrong rider: " + foundEmployees.get(1).getId(), foundEmployees.get(1).getId() == employeeId1);
            }
            CostCenter costCenter1 = employee1.getCostCenter();
            CostCenter costCenter2 = employee2.getCostCenter();
            assertTrue(costCenter1 != null);
            assertTrue(costCenter1.getId() == costCenterId);
            assertTrue(costCenter2 != null);
            assertTrue(costCenter2.getId() == costCenterId);
            costCenter.setEmployees(null);
            employee1.setCostCenter(null);
            employee2.setCostCenter(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(CostCenter.class, costCenterId));
            assertTrue(!cache.contains(Employee.class, employeeId1));
            assertTrue(!cache.contains(Employee.class, employeeId2));
            costCenter = em.find(CostCenter.class, costCenterId);
            employee1 = em.find(Employee.class, employeeId1);
            employee2 = em.find(Employee.class, employeeId2);
            assertTrue(costCenter.getEmployees().size() == 0);
            assertTrue(employee1.getCostCenter() == null);
            assertTrue(employee2.getCostCenter() == null);
        } finally {
            closeEntityManager(em);
        }
    }

    /**
     * Test case: MotorVehicle.driver
     * <p>
     * Relationship mapping: ToOneFK, FetchType: lazy, owning side: left, cacheable: right
     */
    @Test
    @Bugzilla(bugid=309681)
    public void testMotorVehicleEmployee() {
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();
        final boolean isLazyToOneEnabled = false;

        MotorVehicle motorVehicle = new MotorVehicle();
        int employeeId = 11;
        Employee employee = new Employee(employeeId, "first", "driver", null);
        motorVehicle.setDriver(employee);
        employee.setMotorVehicle(motorVehicle);
        try {
            env.beginTransaction(em);
            em.persist(motorVehicle);
            em.persist(employee);
            env.commitTransactionAndClear(em);
            Short motorVehicleId = motorVehicle.getId();

            em.find(MotorVehicle.class, motorVehicleId);
            if (isLazyToOneEnabled) {
                assertTrue(!cache.contains(Employee.class, employeeId));
                employee = em.find(Employee.class, employeeId);
                // assertTrue(employee instanceof LazilyLoadable); FIXME
                // assertTrue( ((LazilyLoadable) employee)._isPending() ); FIXME
            } else {
                assertTrue(cache.contains(Employee.class, employeeId));
            }

            env.beginTransaction(em);
            motorVehicle = em.find(MotorVehicle.class, motorVehicleId);
            employee = em.find(Employee.class, employeeId);
            assertTrue(employeeId == motorVehicle.getDriver().getId());
            assertTrue(motorVehicleId.equals(employee.getMotorVehicle().getId()));
            assertTrue(employee == motorVehicle.getDriver());
            motorVehicle.setDriver(null);
            employee.setMotorVehicle(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(Employee.class, employeeId));
            motorVehicle = em.find(MotorVehicle.class, motorVehicleId);
            employee = em.find(Employee.class, employeeId);
            assertTrue(motorVehicle.getDriver() == null);
            assertTrue(employee.getMotorVehicle() == null);
        } finally {
            closeEntityManager(em);
        }
    }

    /**
     * Test case: Employee.cubicle
     * <p>
     * Relationship mapping: ToOneFK, FetchType: eager, owning side: right, cacheable: both
     */
    @Test
    @Bugzilla(bugid=309681)
    public void testCubicleEmployee() {
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();

        int employeeId = 21;
        Employee employee = new Employee(employeeId, "first", "last", null);
        CubiclePrimaryKeyClass cubicleId = new CubiclePrimaryKeyClass(1, 2);
        Cubicle cubicle = new Cubicle(cubicleId, "red", employee);
        employee.setCubicle(cubicle);
        try {
            env.beginTransaction(em);
            em.persist(employee);
            em.persist(cubicle);
            env.commitTransactionAndClear(em);

            em.find(Cubicle.class, cubicleId);
            assertTrue(cache.contains(Cubicle.class, cubicleId));
            assertTrue(cache.contains(Employee.class, employeeId));

            env.beginTransaction(em);
            cubicle = em.find(Cubicle.class, cubicleId);
            employee = em.find(Employee.class, employeeId);
            assertTrue("cubicle has wrong employee: " + cubicle.getEmployee().getId(), employeeId == cubicle.getEmployee()
                    .getId());
            assertTrue("employee has wrong cubicle: " + employee.getCubicle().getId(), cubicleId.equals(employee.getCubicle()
                    .getId()));
            cubicle.setEmployee(null);
            employee.setCubicle(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(Cubicle.class, cubicleId));
            assertTrue(!cache.contains(Employee.class, employeeId));
            cubicle = em.find(Cubicle.class, cubicleId);
            employee = em.find(Employee.class, employeeId);
            assertTrue(cubicle.getEmployee() == null);
            assertTrue(employee.getCubicle() == null);
        } finally {
            closeEntityManager(em);
        }
    }

    /**
     * Test case: Bicycle.employees
     * <p>
     * Relationship mapping: ToManyJoinTable, FetchType: eager, owning side: left, cacheable: right
     */
    @Test
    @Bugzilla(bugid=309681)
    public void testBicycleEmployee() {
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();

        Bicycle bicycle = new Bicycle();
        int employeeId1 = 31;
        int employeeId2 = 32;
        Employee employee1 = new Employee(employeeId1, "good", "rider1", null);
        Employee employee2 = new Employee(employeeId2, "bad", "rider2", null);
        employee1.addBicycle(bicycle); // maintains also bicycle.riders relationship
        employee2.addBicycle(bicycle);
        try {
            env.beginTransaction(em);
            em.persist(bicycle);
            em.persist(employee1);
            em.persist(employee2);
            env.commitTransactionAndClear(em);
            Short bicycleId = bicycle.getId();

            em.find(Bicycle.class, bicycleId); // eager loading of Employees
            assertTrue(cache.contains(Employee.class, employeeId1));
            assertTrue(cache.contains(Employee.class, employeeId2));

            env.beginTransaction(em);
            bicycle = em.find(Bicycle.class, bicycleId);
            employee1 = em.find(Employee.class, employeeId1);
            employee2 = em.find(Employee.class, employeeId2);
            Collection<Employee> foundRiders = bicycle.getRiders();
            assertTrue(foundRiders != null);
            assertTrue("wrong number of riders: " + foundRiders.size(), foundRiders.size() == 2);
            Employee[] ridersArray = foundRiders.toArray(new Employee[2]);
            if (ridersArray[0].getId() == employeeId1) {
                assertTrue("wrong rider: " + ridersArray[1].getId(), ridersArray[1].getId() == employeeId2);
            } else {
                assertTrue("wrong rider: " + ridersArray[0].getId(), ridersArray[0].getId() == employeeId2);
                assertTrue("wrong rider: " + ridersArray[1].getId(), ridersArray[1].getId() == employeeId1);
            }
            Set<Bicycle> bicycles1 = employee1.getBicycles();
            Set<Bicycle> bicycles2 = employee2.getBicycles();
            assertTrue(bicycles1 != null);
            assertTrue(bicycles2 != null);
            assertTrue(bicycles1.size() == 1);
            assertTrue(bicycles2.size() == 1);
            assertTrue(bicycleId.equals(bicycles1.toArray(new Bicycle[1])[0].getId()));
            assertTrue(bicycleId.equals(bicycles2.toArray(new Bicycle[1])[0].getId()));
            bicycle.setRiders(null);
            employee1.setBicycles(null);
            employee2.setBicycles(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(Employee.class, employeeId1));
            assertTrue(!cache.contains(Employee.class, employeeId2));
            bicycle = em.find(Bicycle.class, bicycleId);
            employee1 = em.find(Employee.class, employeeId1);
            employee2 = em.find(Employee.class, employeeId2);
            assertTrue(bicycle.getRiders().size() == 0);
            assertTrue(employee1.getBicycles().size() == 0);
            assertTrue(employee2.getBicycles().size() == 0);
        } finally {
            closeEntityManager(em);
        }
    }

    /**
     * Test case: Employee.projects
     * <p>
     * Relationship mapping: ToManyJoinTable, FetchType: lazy, owning side: left, cacheable: both
     */
    @SuppressWarnings("unchecked")
    @Test
    @Bugzilla(bugid=309681)
    public void testEmployeeProject() {
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();

        int employeeId = 41;
        Employee employee = new Employee(employeeId, "aaa", "member", null);
        Project project1 = new Project("evaluation");
        Project project2 = new Project("demotivation");
        project1.addEmployee(employee); // maintains also employee.projects relationship
        project2.addEmployee(employee);
        try {
            env.beginTransaction(em);
            em.persist(employee);
            em.persist(project1);
            em.persist(project2);
            env.commitTransactionAndClear(em);
            Integer projectId1 = project1.getId();
            Integer projectId2 = project2.getId();

            env.beginTransaction(em);
            employee = em.find(Employee.class, employeeId);
            assertTrue(cache.contains(Employee.class, employeeId));
            assertTrue(!cache.contains(Project.class, projectId1)); // lazy loading of projects
            assertTrue(!cache.contains(Project.class, projectId2));
            employee.getProjects().size();
            assertTrue(cache.contains(Project.class, projectId1));
            assertTrue(cache.contains(Project.class, projectId2));
            project1 = em.find(Project.class, projectId1);
            project2 = em.find(Project.class, projectId2);
            Set<Project> foundProjects = employee.getProjects();
            assertTrue(foundProjects != null);
            assertTrue("wrong number of projects: " + foundProjects.size(), foundProjects.size() == 2);
            Project[] projArray = foundProjects.toArray(new Project[2]);
            if (projArray[0].getId().equals(projectId1)) {
                assertTrue("wrong project: " + projArray[1].getId(), projArray[1].getId().equals(projectId2));
            } else {
                assertTrue("wrong project: " + projArray[0].getId(), projArray[0].getId().equals(projectId2));
                assertTrue("wrong project: " + projArray[1].getId(), projArray[1].getId().equals(projectId1));
            }
            Set<Employee> employees1 = project1.getEmployees();
            Set<Employee> employees2 = project2.getEmployees();
            assertTrue(employees1 != null);
            assertTrue(employees2 != null);
            assertTrue(employees1.size() == 1);
            assertTrue(employees2.size() == 1);
            assertTrue(employees1.toArray(new Employee[1])[0].getId() == employeeId);
            assertTrue(employees2.toArray(new Employee[1])[0].getId() == employeeId);
            employee.setProjects(null);
            project1.setEmployees(null);
            project2.setEmployees(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(Employee.class, employeeId));
            assertTrue(!cache.contains(Project.class, projectId1));
            assertTrue(!cache.contains(Project.class, projectId2));
            employee = em.find(Employee.class, employeeId);
            project1 = em.find(Project.class, projectId1);
            project2 = em.find(Project.class, projectId2);
            assertTrue(employee.getProjects().size() == 0);
            assertTrue(project1.getEmployees().size() == 0);
            assertTrue(project2.getEmployees().size() == 0);
        } finally {
            closeEntityManager(em);
        }
    }

    /**
     * Test case: TravelProfile.vehicles
     * <p>
     * Relationship mapping: ToManyJoinTable, FetchType: lazy, owning side: right, cacheable: right
     */
    @SuppressWarnings("unchecked")
    @Test
    @ToBeInvestigated
    public void testTravelProfileVehicle() { // TODO remove
        final JPAEnvironment env = getEnvironment();
        final EntityManager em = env.getEntityManager();
        final Cache cache = em.getEntityManagerFactory().getCache();

        byte[] travelProfileId = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
        TravelProfile travelProfile = new TravelProfile(travelProfileId, true, "neverComeBack");
        Vehicle vehicle1 = new Vehicle();
        Vehicle vehicle2 = new Vehicle();
        vehicle1.addProfile(travelProfile); // maintains also travelProfile.vehicles relationship
        vehicle2.addProfile(travelProfile);
        try {
            env.beginTransaction(em);
            em.persist(travelProfile);
            em.persist(vehicle1);
            em.persist(vehicle2);
            env.commitTransactionAndClear(em);
            Short vehicleId1 = vehicle1.getId();
            Short vehicleId2 = vehicle2.getId();

            env.beginTransaction(em);
            travelProfile = em.find(TravelProfile.class, travelProfileId);
            assertTrue(!cache.contains(Vehicle.class, vehicleId1)); // lazy loading of vehicles
            assertTrue(!cache.contains(Vehicle.class, vehicleId2));
            travelProfile.getVehicles().size();
            assertTrue(cache.contains(Vehicle.class, vehicleId1));
            assertTrue(cache.contains(Vehicle.class, vehicleId2));
            vehicle1 = em.find(Vehicle.class, vehicleId1);
            vehicle2 = em.find(Vehicle.class, vehicleId2);
            Set<Vehicle> foundVehicles = travelProfile.getVehicles();
            assertTrue(foundVehicles != null);
            assertTrue("wrong number of vehicles: " + foundVehicles.size(), foundVehicles.size() == 2);
            Vehicle[] vehicleArray = foundVehicles.toArray(new Vehicle[2]);
            if (vehicleArray[0].getId().equals(vehicleId1)) {
                assertTrue("wrong vehicle: " + vehicleArray[1].getId(), vehicleArray[1].getId().equals(vehicleId2));
            } else {
                assertTrue("wrong vehicle: " + vehicleArray[0].getId(), vehicleArray[0].getId().equals(vehicleId2));
                assertTrue("wrong vehicle: " + vehicleArray[1].getId(), vehicleArray[1].getId().equals(vehicleId1));
            }
            Set<TravelProfile> travelProfiles1 = vehicle1.getProfiles();
            Set<TravelProfile> travelProfiles2 = vehicle2.getProfiles();
            assertTrue(travelProfiles1 != null);
            assertTrue(travelProfiles2 != null);
            assertTrue(travelProfiles1.size() == 1);
            assertTrue(travelProfiles2.size() == 1);
            assertTrue(Arrays.equals(travelProfiles1.toArray(new TravelProfile[1])[0].getGuid(), travelProfileId));
            assertTrue(Arrays.equals(travelProfiles2.toArray(new TravelProfile[1])[0].getGuid(), travelProfileId));
            travelProfile.setVehicles(null);
            vehicle1.setProfiles(null);
            vehicle2.setProfiles(null);
            env.commitTransactionAndClear(em);

            assertTrue(!cache.contains(Vehicle.class, vehicleId1));
            assertTrue(!cache.contains(Vehicle.class, vehicleId2));
            travelProfile = em.find(TravelProfile.class, travelProfileId);
            vehicle1 = em.find(Vehicle.class, vehicleId1);
            vehicle2 = em.find(Vehicle.class, vehicleId2);
            assertTrue(travelProfile.getVehicles().size() == 0);
            assertTrue(vehicle1.getProfiles().size() == 0);
            assertTrue(vehicle2.getProfiles().size() == 0);
        } finally {
            closeEntityManager(em);
        }
    }

    @Test
    /**
     * just for the case that all other methods are skipped 
     */
    public void dummyTestMethod() {
        return;
    }

}