/******************************************************************************
 * Copyright (c) 2005 BEA Systems, Inc.
 * 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:
 *    Konstantin Komissarchik - initial API and implementation
 ******************************************************************************/

package org.eclipse.jst.j2ee.project.facet;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.SubProgressMonitor;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jst.common.project.facet.core.ClasspathHelper;
import org.eclipse.jst.common.project.facet.core.IClasspathProvider;
import org.eclipse.jst.common.project.facet.core.internal.FacetCorePlugin;
import org.eclipse.wst.common.componentcore.ComponentCore;
import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
import org.eclipse.wst.common.project.facet.core.IDelegate;
import org.eclipse.wst.common.project.facet.core.IFacetedProject;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.IRuntimeChangedEvent;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
import org.osgi.service.prefs.BackingStoreException;

/**
 * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
 */

public final class J2EEFacetRuntimeChangedDelegate 

    implements IDelegate
    
{
	public static final String LEGACY_METADATA_FILE_NAME 
    = ".settings/org.eclipse.jst.common.project.facet.core.prefs"; //$NON-NLS-1$
	private static final String OWNER_PROJECT_FACETS_ATTR = "owner.project.facets"; //$NON-NLS-1$
    public void execute( final IProject project, 
                         final IProjectFacetVersion fv,
                         final Object cfg,
                         final IProgressMonitor monitor )
    
        throws CoreException
        
    {
        if( monitor != null )
        {
            monitor.beginTask( "", 11 ); //$NON-NLS-1$
        }
        
        try
        {
        	IRuntimeChangedEvent event = (IRuntimeChangedEvent)cfg;
        	// Using our remove Utility to first check for missing preferences
            removeClasspathEntries( project, fv,  event.getOldRuntime());
            
            if( ! ClasspathHelper.addClasspathEntries( project, fv ) )
            {
                // TODO: Support the no runtime case.
                // ClasspathHelper.addClasspathEntries( project, fv, <something> );
            }
            
            if( monitor != null )
            {
                monitor.worked( 1 );
            }
            
            // Cascade this runtime change to projects referenced by this project
            
            // Compile the list of projects referenced by this project.
            final Set<IProject> childProjects = new HashSet<IProject>();
            
            final IVirtualComponent projectVC = ComponentCore.createComponent( project );                       
            
            Map<String, Object> options = new HashMap<String, Object>();
            options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.HARD_REFERENCES);
            final IVirtualReference[] vrefs = projectVC.getReferences(options);
                       	            
            for( int i = 0; i < vrefs.length; i++ ) {
                final IVirtualReference vref = vrefs[ i ];
                final IVirtualComponent vc = vref.getReferencedComponent();
                childProjects.add( vc.getProject() );
            }
            
            if( monitor != null ) {
                monitor.worked( 1 );
            }
            
            // Attempt to change the runtime for each of the referenced projects.                
            updateProjectRuntime( project, childProjects, submon( monitor, 9 ) );
        }
        finally
        {
            if( monitor != null )
            {
                monitor.done();
            }
        }
    }
    private void removeClasspathEntries(IProject project, IProjectFacetVersion fv, IRuntime oldRuntime) throws CoreException {
		IJavaProject jproj = JavaCore.create(project);
		List cp = getClasspath(jproj);
		boolean hasPrefs = hasClasspathPreferencesNode(project);

		// In the case where no prefs exists... make sure the entries of the
		// oldRuntime are removed before continuing
		if (!hasPrefs) {
			removeOnlyCPEntries(project, fv, jproj, cp, oldRuntime);
		} else
			ClasspathHelper.removeClasspathEntries(project, fv);
	}
    private boolean hasClasspathPreferencesNode(IProject project) {
    	
    	IProject pj = project.getProject();
        IFile legacyMetadataFile = pj.getFile( LEGACY_METADATA_FILE_NAME );
        // First check if file exists
        if( legacyMetadataFile.exists() ) {
        	ProjectScope scope = new ProjectScope(project);
        	IEclipsePreferences pluginRoot = scope.getNode(FacetCorePlugin.PLUGIN_ID);
        	try {
        		return pluginRoot.nodeExists("classpath.helper"); //$NON-NLS-1$
        	} catch (BackingStoreException e) {
        		org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
        	}
        }
        //Now check classpath entries for new attributes
        IJavaProject jproj = JavaCore.create( project );
        return hasClasspathPreferencesNode(jproj);
		
	}
	private boolean hasClasspathPreferencesNode(IJavaProject jproj) {
		
		boolean attributeFound = false;
		IClasspathEntry[] entries = null;
		try {
			entries = jproj.getRawClasspath();
		} catch (JavaModelException e) {
			org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin.logError(e);
		}
		int i = 0;
		if (entries != null) {
			while (!attributeFound && i < entries.length) {
				IClasspathEntry cpe = entries[i];
				attributeFound = hasOwnerAttribute( cpe );
				i++;
			} 
		}
		return attributeFound;
		
	}
	private boolean hasOwnerAttribute(IClasspathEntry cpe) {
		 if( cpe != null )
	        {
	            for( IClasspathAttribute attr : cpe.getExtraAttributes() )
	            {
	                if( attr.getName().equals( OWNER_PROJECT_FACETS_ATTR ) )
	                	return true;
	            }
	        }
		 return false;
	}
	private void removeOnlyCPEntries(final IProject project, final IProjectFacetVersion fv, final IJavaProject jproj, final List cp,
			IRuntime oldRuntime) throws CoreException {
		IFacetedProject fproj = ProjectFacetsManager.create(project);
		IRuntime runtime = (oldRuntime != null) ? oldRuntime : fproj.getPrimaryRuntime();
	
		if (runtime != null) {
			IClasspathProvider cpprov = (IClasspathProvider) runtime.getAdapter(IClasspathProvider.class);
			List cpentries = cpprov.getClasspathEntries(fv);
			boolean realCPChanged = false;
			if (cpentries != null) {
			for (Iterator itr = cpentries.iterator(); itr.hasNext();) {
				IClasspathEntry cpentry = (IClasspathEntry) itr.next();
				IPath path = cpentry.getPath();
				boolean contains = cp.contains(cpentry);
	
				if (contains) {
					for (Iterator itr2 = cp.iterator(); itr2.hasNext();) {
						final IClasspathEntry realEntry = (IClasspathEntry) itr2.next();
	
						if (realEntry.getPath().equals(path)) {
							itr2.remove();
							realCPChanged = true;
							break;
						}
					}
				}
			}
			}
			if (realCPChanged) {
				IClasspathEntry[] newcp = (IClasspathEntry[]) cp.toArray(new IClasspathEntry[cp.size()]);
				jproj.setRawClasspath(newcp, null);
			}
		}
	}
	private List getClasspath(final IJavaProject jproj)
	
	throws CoreException
	
	{
		ArrayList list = new ArrayList();
		IClasspathEntry[] cp = jproj.getRawClasspath();
	
		for (int i = 0; i < cp.length; i++) {
			list.add(cp[i]);
		}
	
		return list;
	}
	
    private static IProgressMonitor submon( final IProgressMonitor parent, final int ticks ) {
        return ( parent == null ? null : new SubProgressMonitor( parent, ticks ) );
    }
    
    public static void updateProjectRuntime( final IProject project,
            final IProject childProject,
            final IProgressMonitor monitor ) throws CoreException {
    	if( monitor != null ) {
    		monitor.beginTask( "", 1 ); //$NON-NLS-1$
    	}

    	try
    	{
    		final IFacetedProject facetedProject = ProjectFacetsManager.create( project );

    		final IRuntime projectRuntime = facetedProject.getRuntime();

    		final IFacetedProject childFacetedProject = ProjectFacetsManager.create( childProject );

    		if( childFacetedProject != null && 
    				! equals(projectRuntime, childFacetedProject.getRuntime()))
    		{
    			boolean supports = true;

    			if( projectRuntime != null )
    			{
    				for( Iterator itr = childFacetedProject.getProjectFacets().iterator(); itr.hasNext(); ) {
    					final IProjectFacetVersion fver = (IProjectFacetVersion) itr.next();

    					if(!projectRuntime.supports(fver)) {
    						supports = false;
    						break;
    					}
    				}
    			}

    			if( supports ) {
    				childFacetedProject.setRuntime(projectRuntime, submon( monitor, 1 ) );
    			}
    		}
    	}
    	finally {
    		if( monitor != null ) {
    			monitor.done();
    		}
    	}
    }

    public static void updateProjectRuntime( final IProject project,
    		final Set<IProject> childProjects,
    		final IProgressMonitor monitor ) throws CoreException {        
    	if( monitor != null ) {
    		monitor.beginTask( "", childProjects.size() ); //$NON-NLS-1$
    	}

    	try {
    		for(final IProject childProject : childProjects) {
    			updateProjectRuntime( project, childProject,
    					submon( monitor, 1 ) );
    		}
    	}
    	finally {
    		if( monitor != null ) {
    			monitor.done();
    		}
    	}
    }
    
    private static boolean equals( final Object obj1, final Object obj2 ) {
        if( obj1 == obj2 ) {
            return true;
        } else if( obj1 == null || obj2 == null ) {
            return false;
        } else {
            return obj1.equals( obj2 );
        }
    }
}