/*******************************************************************************
 * Copyright (c) 1998, 2011 Oracle. 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.sdo.model.changesummary.sequence;

import commonj.sdo.ChangeSummary;
import commonj.sdo.DataObject;
import commonj.sdo.Property;
import commonj.sdo.Sequence;
import java.io.FileInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import junit.textui.TestRunner;
import org.eclipse.persistence.sdo.SDOSequence;
import org.eclipse.persistence.testing.sdo.SDOTestCase;
import org.eclipse.persistence.exceptions.SDOException;

public class ChangeSummaryGetOldSequenceTestCases extends SDOTestCase {
    DataObject companyObject;
    DataObject purchaseOrderObject;
    DataObject address1Object;
    DataObject itemsObject;
    ChangeSummary cs;

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

    public static void main(String[] args) {
        String[] arguments = { "-c", "org.eclipse.persistence.testing.sdo.model.changesummary.sequence.ChangeSummaryGetOldSequenceTestCases" };
        TestRunner.main(arguments);
    }

    public void setUp() {
        super.setUp();

        try {
            InputStream is = new FileInputStream(getSchemaToDefine());
            List types = xsdHelper.define(is, null);

            //     XMLDocument doc = xmlHelper.load(new FileInputStream(getControlFileName()));
            //companyObject= doc.getRootObject();
        } catch (Exception e) {
            e.printStackTrace();
            fail("An error occurred during setup.");
        }
        companyObject = buildDataObjects();
        purchaseOrderObject = companyObject.getDataObject("order");
        assertNotNull(purchaseOrderObject);
        address1Object = (DataObject)(purchaseOrderObject.getList("address")).get(0);
        assertNotNull(address1Object);
        assertTrue(address1Object.getType().isSequenced());
        assertNotNull(address1Object.getSequence());
        assertNotNull(purchaseOrderObject.getChangeSummary());
        itemsObject = purchaseOrderObject.getDataObject("items");
        assertNotNull(itemsObject);
        assertNotNull(itemsObject.getSequence());
        cs = purchaseOrderObject.getChangeSummary();

    }

    public String getSchemaToDefine() {
        return "org/eclipse/persistence/testing/sdo/schemas/PurchaseOrderComplexSequenced.xsd";
    }

    protected String getControlFileName() {
        return "./org/eclipse/persistence/testing/sdo/helper/xmlhelper/sequence/purchaseOrderComplexSequenced.xml";
    }

    public void testGetOldSequenceNotLogging() {
        cs.endLogging();
        address1Object.set("city", "aaa");
        List oldValues = cs.getOldValues(address1Object);
        assertEquals(0, oldValues.size());
        address1Object.unset(address1Object.getInstanceProperty("city"));
        Sequence oldAddressSeq = cs.getOldSequence(address1Object);

        assertNotNull(oldAddressSeq);
    }

    public void testGetOldSequenceNotLoggingNull() {
        purchaseOrderObject.unset("address");
        cs.endLogging();
        address1Object.unset(address1Object.getInstanceProperty("city"));
        Sequence oldAddressSeq = cs.getOldSequence(address1Object);

        assertNotNull(oldAddressSeq);
    }

    public void testGetOldSequenceNotSequenced() {
        cs.beginLogging();
        DataObject lineItem1 = (DataObject)itemsObject.getList("item").get(0);
        assertNotNull(lineItem1);
        lineItem1.unset(0);
        Sequence oldLineItemSeq = cs.getOldSequence(lineItem1);

        //old seq should be null because line item is not sequenced
        assertNull(oldLineItemSeq);
    }

    public void testGetOldSequenceNull() {
        cs.beginLogging();

        Sequence oldSeq = cs.getOldSequence(null);
        assertNull(oldSeq);
    }

    public void testGetOldSequenceTwice() {
        Sequence originalSeq = address1Object.getSequence();
        String originalValue = (String)originalSeq.getValue(0);
        assertEquals("Alice Smith", originalValue);
        cs.beginLogging();
        address1Object.set("name", "newName");

        Sequence oldSeq1 = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq1);
        assertNotSame(oldSeq1, originalSeq);

        Sequence oldSeq2 = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq2);
        assertEquals(oldSeq1, oldSeq2);

        address1Object.set("name", "newName2");

        Sequence oldSeq3 = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq3);
        assertEquals(oldSeq2, oldSeq3);		   
        
        String oldSeqValue = (String)oldSeq3.getValue(0);
        assertEquals("Alice Smith", oldSeqValue);

        String currentValue = (String)address1Object.getSequence().getValue(0);
        assertEquals("newName2", currentValue);
    }

    public void testGetOldSequenceAndOldValueAreEqual() {
        cs.beginLogging();

        DataObject lineItem1 = (DataObject)itemsObject.getList("item").get(0);
        assertNotNull(lineItem1);
        lineItem1.delete();

        Sequence oldSeq1 = cs.getOldSequence(itemsObject);
        assertNotNull(oldSeq1);
        Object seqFirstOldValue = oldSeq1.getValue(0);

        ChangeSummary.Setting itemOldSetting = cs.getOldValue(itemsObject, itemsObject.getInstanceProperty("item"));
        assertNotNull(itemOldSetting);
        Object firstValue = ((List)itemOldSetting.getValue()).get(0);
        assertEquals(seqFirstOldValue, firstValue);
    }

    public void testGetOldSequenceCreated() {
        cs.beginLogging();

        DataObject newAddress = dataFactory.create("http://www.example.org", "AddressType");
        assertNotNull(newAddress);
        newAddress.set("city", "newCity");

        purchaseOrderObject.getList("address").add(newAddress);

        assertCreated(newAddress, cs);
        assertNull(cs.getOldSequence(newAddress));
    }

    public void testGetOldSequenceUnchanged() {
        cs.beginLogging();
        //if the sequence has not changed return the current sequence
        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(4, ((SDOSequence)oldSeq).getSettings().size());

        assertEquals("name", oldSeq.getProperty(0).getName());
        assertEquals("street", oldSeq.getProperty(1).getName());
        assertEquals("city", oldSeq.getProperty(2).getName());
        assertEquals("state", oldSeq.getProperty(3).getName());

        assertEquals("Alice Smith", oldSeq.getValue(0));
        assertEquals("123 Maple Street", oldSeq.getValue(1));
        assertEquals("Mill Valley", oldSeq.getValue(2));
        assertEquals("CA", oldSeq.getValue(3));
    }

    public void testGetOldSequenceDetachedAddress() {
        cs.beginLogging();

        address1Object.detach();
        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(4, ((SDOSequence)oldSeq).getSettings().size());

        assertEquals("name", oldSeq.getProperty(0).getName());
        assertEquals("street", oldSeq.getProperty(1).getName());
        assertEquals("city", oldSeq.getProperty(2).getName());
        assertEquals("state", oldSeq.getProperty(3).getName());

        assertEquals("Alice Smith", oldSeq.getValue(0));
        assertEquals("123 Maple Street", oldSeq.getValue(1));
        assertEquals("Mill Valley", oldSeq.getValue(2));
        assertEquals("CA", oldSeq.getValue(3));

    }

    public void testGetOldSequenceDetachedItem() {
        DataObject lineItem1 = (DataObject)itemsObject.getList("item").get(0);
        DataObject lineItem2 = (DataObject)itemsObject.getList("item").get(1);
        Sequence currentSeq = itemsObject.getSequence();
        assertEquals(2, currentSeq.size());

        cs.beginLogging();
        lineItem1.detach();
        assertEquals(1, currentSeq.size());
        Sequence oldSeq = cs.getOldSequence(itemsObject);
        assertNotNull(oldSeq);
        assertEquals(2, ((SDOSequence)oldSeq).getSettings().size());

        DataObject oldLineItem1 = (DataObject)oldSeq.getValue(0);
        assertEquals("Lawnmower", oldLineItem1.get("productName"));

        DataObject oldLineItem2 = (DataObject)oldSeq.getValue(1);
        assertEquals("Baby Monitor", oldLineItem2.get("productName"));
        //should be a deep copy not the same object
        assertNotSame(lineItem1, oldLineItem1);
        assertNotSame(lineItem2, oldLineItem2);
        assertFalse(lineItem1.equals(oldLineItem1));
        assertFalse(lineItem2.equals(oldLineItem2));

    }

    public void testGetOldSequenceDeletedAddress() {
        cs.beginLogging();
        Sequence currentSeq = address1Object.getSequence();
        assertEquals(4, currentSeq.size());
        address1Object.delete();
        assertEquals(0, currentSeq.size());
        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(4, ((SDOSequence)oldSeq).getSettings().size());
    }

    public void testGetOldSequenceDeletedItem() {
        cs.beginLogging();
        DataObject lineItem1 = (DataObject)itemsObject.getList("item").get(0);
        DataObject lineItem2 = (DataObject)itemsObject.getList("item").get(1);
        Sequence currentSeq = itemsObject.getSequence();
        assertEquals(2, currentSeq.size());

        cs.beginLogging();
        lineItem1.delete();
        assertEquals(1, currentSeq.size());
        Sequence oldSeq = cs.getOldSequence(itemsObject);
        assertNotNull(oldSeq);
        assertEquals(2, ((SDOSequence)oldSeq).getSettings().size());

        DataObject oldLineItem1 = (DataObject)oldSeq.getValue(0);
        assertEquals("Lawnmower", oldLineItem1.get("productName"));

        DataObject oldLineItem2 = (DataObject)oldSeq.getValue(1);
        assertEquals("Baby Monitor", oldLineItem2.get("productName"));
        //should be a deep copy not the same object
        assertNotSame(lineItem1, oldLineItem1);
        assertNotSame(lineItem2, oldLineItem2);
        assertFalse(lineItem1.equals(oldLineItem1));
        assertFalse(lineItem2.equals(oldLineItem2));
    }

    public void testGetOldSequenceReattachedItem() {
        DataObject lineItem1 = (DataObject)itemsObject.getList("item").get(0);
        cs.beginLogging();
        lineItem1.detach();
        assertEquals(1, itemsObject.getSequence().size());
        DataObject firstObject = (DataObject)itemsObject.getSequence().getValue(0);
        assertEquals("Baby Monitor", firstObject.get("productName"));

        itemsObject.getList("item").add(lineItem1);
        assertEquals(2, itemsObject.getSequence().size());

        DataObject firstObjectAgain = (DataObject)itemsObject.getSequence().getValue(0);
        assertEquals("Baby Monitor", firstObjectAgain.get("productName"));

        Sequence oldSeq = cs.getOldSequence(itemsObject);
        assertNotNull(oldSeq);
        assertEquals(2, oldSeq.size());

        DataObject firstObjectOld = (DataObject)oldSeq.getValue(0);
        assertEquals("Lawnmower", firstObjectOld.get("productName"));

    }

    public void testGetOldSequenceReattached() {
        cs.beginLogging();
        address1Object.detach();
        purchaseOrderObject.getList("address").add(address1Object);
        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
    }

    public void testGetOldSequenceAfterUnsetAllOnAddress() {
        cs.beginLogging();

        address1Object.unset(3);
        address1Object.unset(2);
        address1Object.unset(1);
        address1Object.unset(0);

        assertEquals(0, ((SDOSequence)address1Object.getSequence()).getSettings().size());
        boolean exception = false;
        try {
            address1Object.getSequence().getProperty(0);
        } catch (SDOException e) {
            //do nothing
            assertEquals(SDOException.INVALID_INDEX ,e.getErrorCode());
            exception = true;
        } finally {
            assertTrue(exception);
            exception = false;
        }
        try {
            address1Object.getSequence().getValue(0);
        } catch (SDOException e) {
            //do nothing
            assertEquals(SDOException.INVALID_INDEX ,e.getErrorCode());
            exception = true;
        } finally {
            assertTrue(exception);
            exception = false;
        }

        Property cityProp = address1Object.getInstanceProperty("city");
        ChangeSummary.Setting cityOldSetting = cs.getOldValue(address1Object, cityProp);
        assertNotNull(cityOldSetting);
        Object oldCityValue = cityOldSetting.getValue();
        assertNotNull(oldCityValue);

        Sequence address1OldSeq = cs.getOldSequence(address1Object);
        assertNotNull(address1OldSeq);

        assertEquals(4, address1OldSeq.size());
    }

    public void testGetOldSequenceAfterUnsetAllOnItems() {
        cs.beginLogging();

        Sequence seq1 = itemsObject.getSequence();

        itemsObject.unset(0);//unset item property

        Sequence seq2 = itemsObject.getSequence();
        assertEquals(seq1, seq2);
        Property itemProp = itemsObject.getInstanceProperty("item");
        ChangeSummary.Setting itemOldSetting = cs.getOldValue(itemsObject, itemProp);
        assertNotNull(itemOldSetting);
        Object oldItemValue = itemOldSetting.getValue();
        assertNotNull(oldItemValue);
        assertTrue(oldItemValue instanceof List);
        assertEquals(2, ((List)oldItemValue).size());

        Sequence itemsOldSeq = cs.getOldSequence(itemsObject);
        assertNotNull(itemsOldSeq);
        assertEquals(itemProp, itemsOldSeq.getProperty(0));
        Object itemOldSeqValue = itemsOldSeq.getValue(0);
        assertNotNull(itemOldSeqValue);
        assertTrue(itemOldSeqValue instanceof DataObject);
        // assertEquals(2, ((DataObject)itemOldSeqValue).size());
        assertEquals(((List)oldItemValue).get(0), itemOldSeqValue);

        /*  assertEquals(((List)oldItemValue).get(0), ((DataObject)itemOldSeqValue).get(0));
          assertEquals(((List)oldItemValue).get(1), ((DataObject)itemOldSeqValue).get(1));
          assertEquals(((List)oldItemValue), ((List)itemOldSeqValue));
        */
        Sequence itemsOldSeq2 = cs.getOldSequence(itemsObject);
        assertEquals(itemsOldSeq, itemsOldSeq2);

    }

    public void testGetOldSequenceWithText() {
        assertEquals(4, address1Object.getSequence().size());
        address1Object.getSequence().addText("abc");
        assertEquals(5, address1Object.getSequence().size());
        cs.beginLogging();

        address1Object.getSequence().addText("def");

        assertEquals(6, address1Object.getSequence().size());
        assertEquals("def", (String)address1Object.getSequence().getValue(5));

        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(5, oldSeq.size());
        assertEquals("abc", (String)oldSeq.getValue(4));
    }

    public void testGetOldSequenceAfterRemoveText() {
        assertEquals(4, address1Object.getSequence().size());
        address1Object.getSequence().addText("abc");
        address1Object.getSequence().addText("def");
        assertEquals(6, address1Object.getSequence().size());
        cs.beginLogging();
        address1Object.getSequence().remove(4);
        assertEquals(5, address1Object.getSequence().size());
        assertEquals("def", (String)address1Object.getSequence().getValue(4));

        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(6, oldSeq.size());
        assertEquals("abc", (String)oldSeq.getValue(4));
        assertEquals("def", (String)oldSeq.getValue(5));
    }

    public void testGetOldSequenceAfterMoveText() {
        assertEquals(4, address1Object.getSequence().size());
        address1Object.getSequence().addText("abc");
        address1Object.getSequence().addText("def");
        assertEquals(6, address1Object.getSequence().size());
        cs.beginLogging();
        assertEquals("abc", (String)address1Object.getSequence().getValue(4));
        assertEquals("def", (String)address1Object.getSequence().getValue(5));
        address1Object.getSequence().move(4, 5);
        assertEquals(6, address1Object.getSequence().size());
        assertEquals("def", (String)address1Object.getSequence().getValue(4));
        assertEquals("abc", (String)address1Object.getSequence().getValue(5));

        Sequence oldSeq = cs.getOldSequence(address1Object);
        assertNotNull(oldSeq);
        assertEquals(6, oldSeq.size());
        assertEquals("abc", (String)oldSeq.getValue(4));
        assertEquals("def", (String)oldSeq.getValue(5));
    }

    private DataObject buildDataObjects() {
        DataObject usAddress = dataFactory.create("http://www.example.org", "usAddressType");
        usAddress.set("name", "Alice Smith");
        List usStreets = new ArrayList();
        usStreets.add("123 Maple Street");
        usAddress.set("street", usStreets);
        usAddress.set("city", "Mill Valley");
        usAddress.set("state", "CA");

        DataObject cdnAddress = dataFactory.create("http://www.example.org", "cdnAddressMailingType");
        cdnAddress.set("name", "Robert Smith");
        List cdnStreets = new ArrayList();
        cdnStreets.add("8 Oak Avenue");

        cdnAddress.set("street", cdnStreets);
        cdnAddress.set("city", "Mill Valley");
        cdnAddress.set("province", "Ontario");
        cdnAddress.set("postalcode", "B3L 4J3");
        cdnAddress.set("deliveryInfo", "usual");

        DataObject items = dataFactory.create("http://www.example.org", "Items");

        DataObject lineItem1 = dataFactory.create("http://www.example.org", "LineItemType");
        lineItem1.set("productName", "Lawnmower");
        lineItem1.set("price", "148.95");
        lineItem1.set("comment", "Confirm this is electric");

        DataObject lineItem2 = dataFactory.create("http://www.example.org", "LineItemType");
        lineItem2.set("productName", "Baby Monitor");
        lineItem2.set("price", "39.98");

        List theItems = new ArrayList();
        theItems.add(lineItem1);
        theItems.add(lineItem2);
        items.set("item", theItems);

        DataObject po = dataFactory.create("http://www.example.org", "PurchaseOrderType");
        List addresses = new ArrayList();
        addresses.add(usAddress);
        addresses.add(cdnAddress);
        po.set("address", addresses);
        po.set("comment", "Hurry, my lawn is going wild");
        po.set("items", items);

        companyObject = dataFactory.create("http://www.example.org", "CompanyType");
        companyObject.set("order", po);

        return companyObject;
    }

    public void testGetOldSequenceSameSettings() {
        org.eclipse.persistence.oxm.sequenced.Setting firstSetting = ((SDOSequence)address1Object.getSequence()).getSettings().get(0);
        cs.beginLogging();
        //modify addressObject        
        address1Object.set("city", "aaa");
        org.eclipse.persistence.oxm.sequenced.Setting secondSetting = ((SDOSequence)address1Object.getSequence()).getSettings().get(0);
        assertTrue(firstSetting == secondSetting);
    }
}
