/*******************************************************************************
 * Copyright (c) 2003, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.tests.activities;

import java.util.HashSet;
import java.util.Set;

import org.eclipse.ui.activities.ActivityEvent;
import org.eclipse.ui.activities.ActivityManagerEvent;
import org.eclipse.ui.activities.CategoryEvent;
import org.eclipse.ui.activities.IActivity;
import org.eclipse.ui.activities.IActivityListener;
import org.eclipse.ui.activities.IActivityManagerListener;
import org.eclipse.ui.activities.ICategory;
import org.eclipse.ui.activities.ICategoryListener;
import org.eclipse.ui.activities.IIdentifier;
import org.eclipse.ui.activities.IIdentifierListener;
import org.eclipse.ui.activities.IdentifierEvent;
import org.eclipse.ui.activities.NotDefinedException;
import org.eclipse.ui.internal.activities.MutableActivityManager;
import org.eclipse.ui.tests.harness.util.UITestCase;

/**
 * 
 * The dynamic test manipualtes the categories, activities and their definitions
 * and ensures that their content and their listeners are behaving properly.
 */
public class DynamicTest extends UITestCase {
    private MutableActivityManager activityManager;

    private DynamicModelActivityRegistry fixedModelRegistry;

    private int listenerType;

    static final int ACTIVITY_ENABLED_CHANGED = 0;

    static final int ACTIVITY_IDS_CHANGED = 1;

    static final int ENABLED_ACTIVITYIDS_CHANGED = 2;

    static final int DEFINED_CATEGORYIDS_CHANGED = 3;

    static final int DEFINED_ACTIVITYIDS_CHANGED = 4;

    static final int DEFINED_CHANGED = 5;

    static final int ENABLED_CHANGED = 6;

    static final int NAME_CHANGED = 7;

    static final int PATTERN_BINDINGS_CHANGED = 8;

    static final int ACTIVITY_ACTIVITY_BINDINGS_CHANGED = 9;

    static final int DESCRIPTION_CHANGED = 10;
    
    static final int DEFAULT_ENABLED_CHANGED = 11;

    /**
     * Constructor.
     * 
     * @param testName
     *            Test's name.
     */
    public DynamicTest(String testName) {
        super(testName);
        fixedModelRegistry = new DynamicModelActivityRegistry();
        activityManager = new MutableActivityManager(fixedModelRegistry);
        listenerType = -1;
    }

    /**
     * Test sizes of what has been read.
     *  
     */
    public void testSizes() {
        assertTrue(activityManager.getDefinedCategoryIds().size() == 6);
        assertTrue(activityManager.getDefinedActivityIds().size() == 18);
        assertTrue(activityManager.getEnabledActivityIds().size() == 3);
    }

    /**
     * Test activity bindings.
     *  
     */
    public void testActivityPatternBindings() {
        IActivity first_activity = activityManager
                .getActivity((String) activityManager.getDefinedActivityIds()
                        .toArray()[0]);
        Set initialPatternBindings = first_activity
                .getActivityPatternBindings();
        // Add pattern binding
        String pattern = "org\\.eclipse\\.ui\\.myPattern/.*"; //$NON-NLS-1$
        fixedModelRegistry.addActivityPatternBinding(first_activity.getId(),
                pattern);
        assertFalse(initialPatternBindings.size() == first_activity
                .getActivityPatternBindings().size());
        // Remove pattern binding
        fixedModelRegistry.removeActivityPatternBinding(pattern);
        assertTrue(initialPatternBindings.size() == first_activity
                .getActivityPatternBindings().size());
    }

    /**
     * Test the enabled activities.
     *  
     */
    public void testEnabledActivities() {
        // Add an enabled activity
        Set compareSet;
        Set copySet = new HashSet(activityManager.getEnabledActivityIds());
        copySet.add(activityManager.getDefinedActivityIds().toArray()[0]);
        activityManager.setEnabledActivityIds(copySet);
        compareSet = activityManager.getEnabledActivityIds();
        assertTrue(compareSet.size() == copySet.size());
        // Remove an enabled activity
        copySet.remove(activityManager.getDefinedActivityIds().toArray()[0]);
        activityManager.setEnabledActivityIds(copySet);
        compareSet = activityManager.getEnabledActivityIds();
        assertTrue(compareSet.size() == copySet.size());
    }

    /**
     * Test the identifier listener.
     *  
     */
    public void testIdentifiersListener() {
        final IIdentifier enabledIdentifier = activityManager
                .getIdentifier("org.eclipse.pattern3"); //$NON-NLS-1$
        assertTrue(enabledIdentifier.isEnabled());
        enabledIdentifier.addIdentifierListener(new IIdentifierListener() {
            public void identifierChanged(IdentifierEvent identifierEvent) {
                switch (listenerType) {
                case ACTIVITY_ENABLED_CHANGED:
                    assertTrue(identifierEvent.hasEnabledChanged());
                    break;
                case ACTIVITY_IDS_CHANGED:
                    assertTrue(identifierEvent.hasActivityIdsChanged());
                    break;
                }
                listenerType = -1;
            }
        });
        // Test correcteness of identifier
        IIdentifier activitiesIdentifier = activityManager
                .getIdentifier("org.eclipse.pattern4"); //$NON-NLS-1$
        Set identifiedActivities = activitiesIdentifier.getActivityIds(); //$NON-NLS-1$
        assertTrue(identifiedActivities.size() == 1);
        assertTrue(((String) identifiedActivities.toArray()[0])
                .equals("org.eclipse.activity4")); //$NON-NLS-1$
        assertFalse(activitiesIdentifier.isEnabled());
        // Disable Enabled activity
        listenerType = 0;
        Set copySet = new HashSet(activityManager.getEnabledActivityIds());
        copySet.remove(enabledIdentifier.getActivityIds().toArray()[0]);
        activityManager.setEnabledActivityIds(copySet);
        assertTrue(listenerType == -1);
        // Enable Disabled activity
        listenerType = 0;
        copySet.add("org.eclipse.activity3"); //$NON-NLS-1$
        activityManager.setEnabledActivityIds(copySet);
        assertTrue(listenerType == -1);
        // Add pattern binding
        listenerType = 1;
        fixedModelRegistry.addActivityPatternBinding("org.eclipse.activity1", //$NON-NLS-1$
                "org.eclipse.pattern3"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Test correctenesss of identifier
        Set manipulatedIdentifiers = activityManager.getIdentifier(
                "org.eclipse.pattern3").getActivityIds(); //$NON-NLS-1$
        assertTrue(manipulatedIdentifiers.size() == 2);
        // Remove pattern binding
        listenerType = 1;
        fixedModelRegistry.removeActivityPatternBinding("org.eclipse.pattern3"); //$NON-NLS-1$
        assertTrue(listenerType == -1);
        manipulatedIdentifiers = activityManager.getIdentifier(
                "org.eclipse.pattern3").getActivityIds(); //$NON-NLS-1$
        assertTrue(manipulatedIdentifiers.size() == 1);
    }

    /**
     * Test the activity manager listener.
     *  
     */
    public void testActivityManagerListener() {
        activityManager
                .addActivityManagerListener(new IActivityManagerListener() {
                    public void activityManagerChanged(
                            ActivityManagerEvent activityManagerEvent) {
                        switch (listenerType) {
                        case ENABLED_ACTIVITYIDS_CHANGED:
                            assertTrue(activityManagerEvent
                                    .haveEnabledActivityIdsChanged());
                            break;
                        case DEFINED_CATEGORYIDS_CHANGED:
                            assertTrue(activityManagerEvent
                                    .haveDefinedCategoryIdsChanged());
                            break;
                        case DEFINED_ACTIVITYIDS_CHANGED:
                            assertTrue(activityManagerEvent
                                    .haveDefinedActivityIdsChanged());
                            break; 
                        }
                        listenerType = -1;
                    }
                });
        // Add an enabled activity
        listenerType = 2;
        Set enabledSet = new HashSet(activityManager.getEnabledActivityIds());
        enabledSet.add("org.eclipse.activity19"); //$NON-NLS-1$
        activityManager.setEnabledActivityIds(enabledSet);
        assertTrue(listenerType == -1);
        // Remove an enabled activity
        listenerType = 2;
        enabledSet.remove("org.eclipse.activity19"); //$NON-NLS-1$
        activityManager.setEnabledActivityIds(enabledSet);
        assertTrue(listenerType == -1);
        // Add categroy
        listenerType = 3;
        fixedModelRegistry.addCategory("org.eclipse.category7", "Category 7"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Remove category
        listenerType = 3;
        fixedModelRegistry.removeCategory("org.eclipse.category7", //$NON-NLS-1$
                "Category 7"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Add activity
        listenerType = 4;
        fixedModelRegistry.addActivity("org.eclipse.activity19", "Activity 19"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Remove activity
        listenerType = 4;
        fixedModelRegistry.removeActivity("org.eclipse.activity19", //$NON-NLS-1$
                "Activity 19"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
    }

    /**
     * Test the activity listener.
     *  
     */
    public void testActivityListener() {
        final IActivity activity_to_listen = activityManager
                .getActivity((String) activityManager.getDefinedActivityIds()
                        .toArray()[0]);
        activity_to_listen.addActivityListener(new IActivityListener() {
            public void activityChanged(ActivityEvent activityEvent) {
                switch (listenerType) {
                case DEFINED_CHANGED:
                    assertTrue(activityEvent.hasDefinedChanged());
                    break;
                case ENABLED_CHANGED:
                    assertTrue(activityEvent.hasEnabledChanged());
                    break;
                case NAME_CHANGED:
                    assertTrue(activityEvent.hasNameChanged());
                    break;
                case PATTERN_BINDINGS_CHANGED:
                    assertTrue(activityEvent
                            .haveActivityPatternBindingsChanged());
                    break;
                case ACTIVITY_ACTIVITY_BINDINGS_CHANGED:
                    assertTrue(activityEvent
                            .haveActivityRequirementBindingsChanged());
                    break;
                case DESCRIPTION_CHANGED:
                    assertTrue(activityEvent.hasDescriptionChanged());
                    break;
                case DEFAULT_ENABLED_CHANGED:
                    assertTrue(activityEvent.hasDefaultEnabledChanged());
                    break;
                }
                listenerType = -1;
            }
        });
        // Remove activity and change name consequently
        try {
            fixedModelRegistry.removeActivity(activity_to_listen.getId(),
                    activity_to_listen.getName());
        } catch (NotDefinedException e) {
            e.printStackTrace(System.err);
        }
        assertTrue(listenerType == -1);
        // Add activity
        listenerType = 5;
        fixedModelRegistry.addActivity(activity_to_listen.getId(),
                "Activity 18"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Add to enabled activity
        listenerType = 6;
        Set enabledSet = new HashSet(activityManager.getEnabledActivityIds());
        enabledSet.add(activity_to_listen.getId());
        activityManager.setEnabledActivityIds(enabledSet);
        assertTrue(listenerType == -1);
        // Remove from enabled activity
        listenerType = 6;
        enabledSet.remove(activity_to_listen.getId());
        activityManager.setEnabledActivityIds(enabledSet);
        assertTrue(listenerType == -1);
        // Add pattern binding
        listenerType = 8;
        fixedModelRegistry.addActivityPatternBinding("org.eclipse.activity18", //$NON-NLS-1$
                "org.eclipse.pattern3"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Remove pattern binding
        listenerType = 8;
        fixedModelRegistry.removeActivityPatternBinding("org.eclipse.pattern3");//$NON-NLS-1$
        assertTrue(listenerType == -1);
        // Add activity activity binding as parent
        listenerType = 9;
        fixedModelRegistry.addActivityRequirementBinding(
                "org.eclipse.activity9", //$NON-NLS-1$
                activity_to_listen.getId());//$NON-NLS-1$
        assertTrue(listenerType == -1);
        // Remove activity activity binding as parent
        listenerType = 9;
        fixedModelRegistry.removeActivityRequirementBinding(
                "org.eclipse.activity9", activity_to_listen.getId());//$NON-NLS-1$
        assertTrue(listenerType == -1);
        //		 Update activity name
        listenerType = 7;
        fixedModelRegistry.updateActivityName(activity_to_listen.getId(),
                "name_change"); //$NON-NLS-1$
        assertTrue(listenerType == -1);
        // Update activity description
        listenerType = 10;
        fixedModelRegistry.updateActivityDescription(
                activity_to_listen.getId(), "description_change"); //$NON-NLS-1$
        assertTrue(listenerType == -1);

        // check default enablement
        listenerType = DEFAULT_ENABLED_CHANGED;
        fixedModelRegistry.addDefaultEnabledActivity(activity_to_listen.getId());
        assertTrue(listenerType == -1);
        try {
            assertTrue(activity_to_listen.isDefaultEnabled());
        } catch (NotDefinedException e1) {
            fail(e1.getMessage());
        }
        
        listenerType = DEFAULT_ENABLED_CHANGED;
        fixedModelRegistry.removeDefaultEnabledActivity(activity_to_listen.getId());
        assertTrue(listenerType == -1);
        try {
            assertFalse(activity_to_listen.isDefaultEnabled());
        } catch (NotDefinedException e1) {
            fail(e1.getMessage());
        }
    }

    /**
     * Test the category listener.
     *  
     */
    public void testCategoryListener() {
        final ICategory category_to_listen = activityManager
                .getCategory((String) activityManager.getDefinedCategoryIds()
                        .toArray()[0]);
        category_to_listen.addCategoryListener(new ICategoryListener() {
            public void categoryChanged(CategoryEvent categoryEvent) {
                switch (listenerType) {
                case DEFINED_CHANGED:
                    assertTrue(categoryEvent.hasDefinedChanged());
                    break;
                case NAME_CHANGED:
                    assertTrue(categoryEvent.hasNameChanged());
                    break;
                case PATTERN_BINDINGS_CHANGED:
                    assertTrue(categoryEvent
                            .haveCategoryActivityBindingsChanged());
                    break;
                case DESCRIPTION_CHANGED:
                    //	assertTrue(categoryEvent.hasDescriptionChanged());
                    break;
                }
                listenerType = -1;
            }
        });
        // Remove category, and change name
        try {
            fixedModelRegistry.removeCategory(category_to_listen.getId(),
                    category_to_listen.getName()); //$NON-NLS-1$
        } catch (NotDefinedException e) {
            e.printStackTrace(System.err);
        }
        assertTrue(listenerType == -1);
        // Add category
        listenerType = 5;
        fixedModelRegistry
                .addCategory(category_to_listen.getId(), "Category 6"); //$NON-NLS-1$ //$NON-NLS-2$
        assertTrue(listenerType == -1);
        // Add category activity binding
        listenerType = 8;
        fixedModelRegistry.addCategoryActivityBinding((String) activityManager
                .getDefinedActivityIds().toArray()[4], category_to_listen
                .getId()); //$NON-NLS-1$
        assertTrue(listenerType == -1);
        // Remove activity activity binding
        listenerType = 8;
        fixedModelRegistry.removeCategoryActivityBinding(
                (String) activityManager.getDefinedActivityIds().toArray()[4],
                category_to_listen.getId());//$NON-NLS-1$
        // Change category description
        listenerType = 10;
        fixedModelRegistry.updateCategoryDescription(
                category_to_listen.getId(), "description_change"); //$NON-NLS-1$
        try {
            assertTrue(category_to_listen.getDescription().equals(
                    "description_change")); //$NON-NLS-1$
        } catch (NotDefinedException e) {
            e.printStackTrace(System.err);
        }
        assertTrue(listenerType == -1);
        // Change category name
        listenerType = 7;
        fixedModelRegistry.updateCategoryName(category_to_listen.getId(),
                "name_change"); //$NON-NLS-1$
        try {
            assertTrue(category_to_listen.getName().equals("name_change")); //$NON-NLS-1$
        } catch (NotDefinedException e) {
            e.printStackTrace(System.err);
        }
        assertTrue(listenerType == -1);
    }
}