package com.onaro.sanscreen.client.view.changes;

import com.onaro.sanscreen.server.changes.Change;
import com.onaro.sanscreen.server.changes.ChangeConstants;
import com.onaro.sanscreen.types.ChangeType;
import com.onaro.sanscreen.types.ObjectType;

import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;


/**
 * Determines the sorting order of a list of {@link Change} objects.
 */
public class ChangeComparator implements Comparator<Change> {
    private static final Logger logger = LogManager.getLogger(ChangeComparator.class);
    
    protected static final String SRC_MAIN_DEVICE_NAME = ChangeConstants.SRC_MAIN_DEVICE + ChangeConstants.NAME;
    protected static final String SRC_MAIN_DEVICE_DEVICE_TYPE = ChangeConstants.SRC_MAIN_DEVICE + ChangeConstants.DEVICE_TYPE;
    protected static final String SRC_SEC_DEVICE_NAME = ChangeConstants.SRC_SEC_DEVICE + ChangeConstants.NAME;
    protected static final String SRC_SEC_DEVICE_DEVICE_TYPE = ChangeConstants.SRC_SEC_DEVICE + ChangeConstants.DEVICE_TYPE;
    protected static final String DEST_MAIN_DEVICE_NAME = ChangeConstants.DEST_MAIN_DEVICE + ChangeConstants.NAME;
    protected static final String DEST_MAIN_DEVICE_DEVICE_TYPE = ChangeConstants.DEST_MAIN_DEVICE + ChangeConstants.DEVICE_TYPE;
    protected static final String DEST_SEC_DEVICE_NAME = ChangeConstants.DEST_SEC_DEVICE + ChangeConstants.NAME;
    protected static final String DEST_SEC_DEVICE_DEVICE_TYPE = ChangeConstants.DEST_SEC_DEVICE + ChangeConstants.DEVICE_TYPE;
    protected static final String SRC_PORT_NAME = ChangeConstants.SRC_PORT + ChangeConstants.NAME;
    protected static final String DEST_PORT_NAME = ChangeConstants.DEST_PORT + ChangeConstants.NAME;
    protected static final String VOLUME_NAME = ChangeConstants.VOLUME + ChangeConstants.NAME;
    protected static final String VOLUME_MAP_STORAGE_PORT_NAME = ChangeConstants.VOLUME_MAP + ChangeConstants.STORAGE_PORT + ChangeConstants.NAME;
    protected static final String VOLUME_MASK_STORAGE_PORT_NAME = ChangeConstants.VOLUME_MASK + ChangeConstants.STORAGE_PORT + ChangeConstants.NAME;
    protected static final String VOLUME_MASK_INITIATOR_DEVICE_NAME = ChangeConstants.VOLUME_MASK + ChangeConstants.INITIATOR_DEVICE + ChangeConstants.NAME;
    protected static final String ZONE_DATA_NAME = ChangeConstants.ZONE_DATA + ChangeConstants.NAME;

    /**
     * Determines the sorting order of changes by mapping the change's type into a number.
     */
    private static final Map<ChangeType,Integer> CHANGE_TYPE_SORT_ORDER = new HashMap<ChangeType, Integer>(50);

    private static final Map<String,Integer> CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER = new HashMap<String, Integer>(10);

    /**
     * Setup the secondary sorting order by the group's type.
     */
    static {
        int i = 0;

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VIOLATION_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VIOLATION_DOWN, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_MASK_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_MASK_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_MAP_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_MAP_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_MAP_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_UP, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SHARE_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SHARE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SHARE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QUOTA_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QUOTA_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QUOTA_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DISK_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DISK_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DISK_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_POOL_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_POOL_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_POOL_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QTREE_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QTREE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QTREE_UP, Integer.valueOf(++i));
        
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NETWORK_PIPE_PORT_WWN_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NETWORK_PIPE_PORT_WWN_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PROTOCOL_END_POINT_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PROTOCOL_END_POINT_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NETWORK_PIPE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NETWORK_PIPE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NETWORK_PIPE_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PROTOCOL_END_POINT_REF_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PROTOCOL_END_POINT_REF_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_STORAGE_SYNC_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_STORAGE_SYNC_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_STORAGE_SYNC_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_STORAGE_SYNC_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_STORAGE_SYNC_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_STORAGE_SYNC_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_REPLICA_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_REPLICA_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOCAL_REPLICA_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_REPLICA_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_REPLICA_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.REMOTE_REPLICA_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_REBOOT, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VIOLATION_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VIOLATION_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOGICAL_PATH_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOGICAL_PATH_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.LOGICAL_PATH_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NAS_PATH_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.NAS_PATH_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.APL_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.APL_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.APL_DOWN, Integer.valueOf(++i));               
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_APL_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_APL_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_APL_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_PATH_POLICY_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_PATH_POLICY_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_PATH_POLICY_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_HOST_POLICY_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_HOST_POLICY_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_HOST_POLICY_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_PATH_ACTIVITY_CHANGED, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.WWN_ZONE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.WWN_ZONE_DOWN, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_LEFT_FABRIC, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_JOINED_FABRIC, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SWITCH_JOINED_FABRIC, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SWITCH_LEFT_FABRIC, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ZONE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ZONE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_ZONE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_ZONE_DOWN, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ROUTING_ZONE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ROUTING_ZONE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ROUTING_ZONE_MEMBER_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ROUTING_ZONE_MEMBER_DOWN, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.APPLICATION_ADDED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.APPLICATION_REMOVED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.BUSINESS_ENTITY_ADDED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.BUSINESS_ENTITY_REMOVED, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HOST_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VM_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VM_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QTREE_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.QTREE_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SHARE_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SHARE_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SWITCH_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.SWITCH_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_ADDED_TO_APPLICATION, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_REMOVED_FROM_APPLICATION, Integer.valueOf(++i));
        
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_CONNECTED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_DISCONNECTED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_ATTRIBUTE_CHANGE, Integer.valueOf(++i));
        
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_ADDED_TO_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.VOLUME_REMOVED_FROM_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_POOL_ADDED_TO_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_POOL_REMOVED_FROM_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_ADDED_TO_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.INTERNAL_VOLUME_REMOVED_FROM_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_ADDED_TO_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.PORT_REMOVED_FROM_STORAGE_NODE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_NODE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_NODE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.STORAGE_NODE_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_CONFIGURATION_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_CREATED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_ATTRIBUTE_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_RESOLVED_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.DEVICE_UNRESOLVED_CHANGE, Integer.valueOf(++i));

        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VM_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VM_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VM_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VM_MOVED_TO_HOST, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_DATASTORE_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_DATASTORE_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_DATASTORE_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VIRTUAL_DISK_ADDED_TO_VM, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_VIRTUAL_DISK_REMOVED_FROM_VM, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_HOST_EXCLUDED_FROM_POLICY, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_HOST_INCLUDED_IN_POLICY, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_HOST_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_HOST_EXCLUDED_FROM_POLICY, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_HOST_INCLUDED_IN_POLICY, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.HV_LUN_POLICY_CHANGED, Integer.valueOf(++i));
        
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_NETWORK_PORTAL_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_NETWORK_PORTAL_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_SESSION_UP, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_SESSION_DOWN, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_NODE_RESOLVED_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_NODE_UNRESOLVED_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_IN_CHAP_CHANGED, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.ISCSI_OUT_CHAP_CHANGED, Integer.valueOf(++i));
        
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.IP_RESOLVED_CHANGE, Integer.valueOf(++i));
        CHANGE_TYPE_SORT_ORDER.put(ChangeType.IP_UNRESOLVED_CHANGE, Integer.valueOf(++i));

        i = 0;

        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.FABRIC.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.SWITCH.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.CONTROLLER.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.TAPE.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.STORAGE.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.ADAPTER.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.HOST.getName(), Integer.valueOf(++i));
        CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.put(ObjectType.UNKNOWN.getName(), Integer.valueOf(++i));
    }


    /**
     * Compares two change groups. The fields in the two groups are compared in
     * the following order:<ol>
     * <li>Change type - The order of types is determined using the <code>CHANGE_TYPE_SORT_ORDER</code> map
     * <li>Source device, sub device and port
     * <li>Destination device, sub device and port
     * <li>Volume
     * <li>Zone
     * <li>Property name
     * <li>Old value
     * <li>New value
     * </ol>
     *
     * @param change1 the first compared group
     * @param change2 the second compared group
     * @return a negative integer, zero, or a positive integer as the
     *         first argument is less than, equal to, or greater than the
     *         second
     */
    public int compare(Change change1, Change change2) {
        int typeCompare = compareChangeTypes(change1.getType(), change2.getType());
        if (typeCompare != 0) {
            return typeCompare;
        }

        int srcDevCompare = compareDevices(change1.getValue(SRC_MAIN_DEVICE_NAME), change1.getValue(SRC_MAIN_DEVICE_DEVICE_TYPE),
                change2.getValue(SRC_MAIN_DEVICE_NAME), change2.getValue(SRC_MAIN_DEVICE_DEVICE_TYPE));
        if (srcDevCompare != 0) {
            return srcDevCompare;
        }

        int srcSubDevCompare = compareDevices(change1.getValue(SRC_SEC_DEVICE_NAME), change1.getValue(SRC_SEC_DEVICE_DEVICE_TYPE),
                change2.getValue(SRC_SEC_DEVICE_NAME), change2.getValue(SRC_SEC_DEVICE_DEVICE_TYPE));
        if (srcSubDevCompare != 0) {
            return srcSubDevCompare;
        }

        int srcPortCompare = compareStrings(change1.getValue(SRC_PORT_NAME), change2.getValue(SRC_PORT_NAME));
        if (srcPortCompare != 0) {
            return srcPortCompare;
        }

        int destDevCompare = compareDevices(change1.getValue(DEST_MAIN_DEVICE_NAME), change1.getValue(DEST_MAIN_DEVICE_DEVICE_TYPE),
                change2.getValue(DEST_MAIN_DEVICE_NAME), change2.getValue(DEST_MAIN_DEVICE_DEVICE_TYPE));
        if (destDevCompare != 0) {
            return destDevCompare;
        }

        int destSubDevCompare = compareDevices(change1.getValue(DEST_SEC_DEVICE_NAME), change1.getValue(DEST_SEC_DEVICE_DEVICE_TYPE),
                change2.getValue(DEST_SEC_DEVICE_NAME), change2.getValue(DEST_SEC_DEVICE_DEVICE_TYPE));
        if (destSubDevCompare != 0) {
            return destSubDevCompare;
        }

        int destPortCompare = compareStrings(change1.getValue(DEST_PORT_NAME), change2.getValue(DEST_PORT_NAME));
        if (destPortCompare != 0) {
            return destPortCompare;
        }

        int volumeCompare = compareVolumes(change1.getValue(VOLUME_NAME), change2.getValue(VOLUME_NAME));
        if (volumeCompare != 0) {
            return volumeCompare;
        }

        int storagePortCompare = compareStrings(change1.getValue(VOLUME_MAP_STORAGE_PORT_NAME), change2.getValue(VOLUME_MAP_STORAGE_PORT_NAME));
        if (storagePortCompare != 0) {
            return storagePortCompare;
        }

        storagePortCompare = compareStrings(change1.getValue(VOLUME_MASK_STORAGE_PORT_NAME), change2.getValue(VOLUME_MASK_STORAGE_PORT_NAME));
        if (storagePortCompare != 0) {
            return storagePortCompare;
        }

        int volumeMaskInitiatorCompare = compareStrings(change1.getValue(VOLUME_MASK_INITIATOR_DEVICE_NAME), change2.getValue(VOLUME_MASK_INITIATOR_DEVICE_NAME));
        if (volumeMaskInitiatorCompare != 0) {
            return volumeMaskInitiatorCompare;
        }

        int zoneCompare = compareZones(change1, change2);
        if (zoneCompare != 0) {
            return zoneCompare;
        }

        int propertyCompare = compareStrings(change1.getValue(ChangeConstants.PROPERTY_NAME), change2.getValue(ChangeConstants.PROPERTY_NAME));
        if (propertyCompare != 0) {
            return propertyCompare;
        }

        int oldCompare = compareStrings(change1.getValue(ChangeConstants.OLD_VALUE), change2.getValue(ChangeConstants.OLD_VALUE));
        if (oldCompare != 0) {
            return oldCompare;
        }

        return compareStrings(change1.getValue(ChangeConstants.NEW_VALUE), change2.getValue(ChangeConstants.NEW_VALUE));
    }


    /**
     * Compares two {@link ChangeType}s
     *
     * @param type1 type of the first change
     * @param type2 type of the first change
     * @return a negative integer, zero, or a positive integer as the
     *         first change is prior to, equal to, or later than the
     *         second
     */
    protected int compareChangeTypes(ChangeType type1, ChangeType type2) {
        Integer type1Index = CHANGE_TYPE_SORT_ORDER.get(type1);
        Integer type2Index = CHANGE_TYPE_SORT_ORDER.get(type2);
        
        // Check for unknown ChangeTypes. Unknown types sorted at end, secondarily sorted by type ID.
        if (type1Index == null) {
            logger.warn ("Unknown sort order for ChangeType " + type1.getName()); //$NON-NLS-1$
            type1Index = Integer.valueOf (CHANGE_TYPE_SORT_ORDER.size() + type1.getTypeId()); 
        }
        if (type2Index == null) {
            logger.warn ("Unknown sort order for ChangeType " + type2.getName()); //$NON-NLS-1$
            type2Index = Integer.valueOf (CHANGE_TYPE_SORT_ORDER.size() + type2.getTypeId()); 
        }

        return type1Index.compareTo(type2Index);
    }

    /**
     * Compares the name of two Devices
     *
     * @return a negative integer, zero, or a positive integer as the
     *         first device is prior to, equal to, or later than the
     *         second
     */
    protected int compareDevices(String name1, String type1, String name2, String type2) {
        if (name1 != name2) {
            if (name1 == null) {
                return -1;
            } else if (name2 == null) {
                return 1;
            } else {
                Integer i1 = CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.get(type1);
                Integer i2 = CHANGE_TYPE_OBJECT_TYPE_SORT_ORDER.get(type2);
                if (i1 == null || i2 == null || i1.intValue() == i2.intValue()) {
                    return name1.compareToIgnoreCase(name2);
                }
                return i1.compareTo(i2);
            }
        }

        return 0;
    }


    /**
     * Compares two Volumes
     * The compare is lexicographic and case insensitive
     *
     * @param vol1 name of the first volume, may be null
     * @param vol2 name of the second volume, may be null
     * @return a negative integer, zero, or a positive integer as the
     *         first volume is greater than, equal to, or later than the
     *         second
     */
    protected int compareVolumes(String vol1, String vol2) {
        return compareStrings(vol1, vol2);
    }


    /**
     * Compares the names of two Zones
     *
     * @param c1 the first change
     * @param c2 the second change
     * @return a negative integer, zero, or a positive integer as the
     *         first zone is prior to, equal to, or greater than the
     *         second
     */
    protected int compareZones(Change c1, Change c2) {
        return compareStrings(c1.getValue(ZONE_DATA_NAME), c2.getValue(ZONE_DATA_NAME));
    }

    /**
     * Compares two {@link String}s
     *
     * @param str1 the first string, may be null
     * @param str2 the second string, may be null
     * @return a negative integer, zero, or a positive integer as the
     *         first string is less than, equal to, or greater than the
     *         second
     */
    protected int compareStrings(String str1, String str2) {
        if (str1 != null) {
            return (str2 != null) ? str1.compareToIgnoreCase(str2) : 1;
        } else {
            return (str2 != null) ? -1 : 0;
        }
    }
}