/******************************************************************************
 * Copyright (c) 2010 Oracle
 * 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 implementation and ongoing maintenance
 ******************************************************************************/

package org.eclipse.jst.common.project.facet.core.internal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
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.IWorkspace;
import org.eclipse.core.resources.ProjectScope;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
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.internal.core.ClasspathEntry;
import org.eclipse.wst.common.project.facet.core.IProjectFacet;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;

/**
 * @author <a href="mailto:konstantin.komissarchik@oracle.com">Konstantin Komissarchik</a>
 */

@SuppressWarnings( "restriction" )
public final class ClasspathUtil
{
    public static final String LEGACY_METADATA_FILE_NAME 
        = ".settings/org.eclipse.jst.common.project.facet.core.prefs"; //$NON-NLS-1$

    public static final Object SYSTEM_OWNER = new Object();
    private static final String OWNER_PROJECT_FACETS_ATTR = "owner.project.facets"; //$NON-NLS-1$
    
    private ClasspathUtil() {}

    public static List<IClasspathEntry> getProjectClasspath( final IJavaProject project )
    
        throws CoreException
        
    {
        final List<IClasspathEntry> result = new ArrayList<IClasspathEntry>();
        
        for( IClasspathEntry cpe : project.getRawClasspath() )
        {
            result.add( cpe );
        }
        
        return result;
    }
    
    public static void setProjectClasspath( final IJavaProject project,
                                            final List<IClasspathEntry> cp )
    
        throws CoreException
        
    {
        validateClasspathEdit( project );
        project.setRawClasspath( cp.toArray( new IClasspathEntry[ cp.size() ] ), null );
    }
    
    public static void addClasspathEntry( final IProject project,
                                          final IClasspathEntry cpe )
    
        throws CoreException
        
    {
        addClasspathEntry( JavaCore.create( project ), cpe );
    }

    public static void addClasspathEntry( final IJavaProject project,
                                          final IClasspathEntry cpe )
    
        throws CoreException
        
    {
        validateClasspathEdit( project );
        
        final IClasspathEntry[] cpOld = project.getRawClasspath();
        final IClasspathEntry[] cpNew = new IClasspathEntry[ cpOld.length + 1 ];
        System.arraycopy( cpOld, 0, cpNew, 0, cpOld.length );
        cpNew[ cpOld.length ] = cpe;
        project.setRawClasspath( cpNew, null );
    }

    public static List<IClasspathEntry> getClasspathEntries( final IProject project,
                                                             final IProjectFacet facet )
                                                             
        throws CoreException
        
    {
        final IJavaProject jproj = JavaCore.create( project );
        return getClasspathEntries( jproj, facet );
    }
    
    public static List<IClasspathEntry> getClasspathEntries( final IJavaProject project,
                                                             final IProjectFacet facet )
    
        throws CoreException
        
    {
        final List<IClasspathEntry> result = new ArrayList<IClasspathEntry>();
        
        for( IClasspathEntry cpe : project.getRawClasspath() )
        {
            final Set<Object> owners = getOwners( project, cpe );
            
            if( owners.contains( facet ) )
            {
                result.add( cpe );
            }
        }
        
        return result;
    }
    
    
    public static void addClasspathEntries( final IProject project,
                                            final IProjectFacet facet,
                                            final List<IClasspathEntry> cpentries )
    
        throws CoreException
        
    {
        final IJavaProject jproj = JavaCore.create( project );
        addClasspathEntries( jproj, facet, cpentries );
    }
    
    public static void addClasspathEntries( final IJavaProject project,
                                            final IProjectFacet facet,
                                            final List<IClasspathEntry> cpentries )
    
        throws CoreException
        
    {
        validateClasspathEdit( project );
        convertLegacyMetadata( project );
        
        final List<IClasspathEntry> cp = getProjectClasspath( project );
        
        for( IClasspathEntry cpe : cpentries )
        {
            IClasspathEntry existingClasspathEntry = null;
            
            for( IClasspathEntry x : cp )
            {
                if( x.getPath().equals( cpe.getPath() ) )
                {
                    existingClasspathEntry = x;
                    break;
                }
            }

            final Set<Object> owners = getOwners( project, existingClasspathEntry );
            
            owners.add( facet );
            
            if( existingClasspathEntry != null )
            {
                final IClasspathEntry annotatedEntry = setOwners( existingClasspathEntry, owners );
                final int existingIndex = cp.indexOf( existingClasspathEntry );
                cp.set( existingIndex, annotatedEntry );
            }
            else
            {
                final IClasspathEntry annotatedEntry = setOwners( cpe, owners );
                cp.add( annotatedEntry );
            }
        }

        setProjectClasspath( project, cp );
    }
    
    public static void removeClasspathEntries( final IProject project,
                                               final IProjectFacet facet )
    
        throws CoreException
        
    {
        final IJavaProject jproj = JavaCore.create( project );
        removeClasspathEntries( jproj, facet );
    }
        
    public static void removeClasspathEntries( final IJavaProject project,
                                               final IProjectFacet facet )
    
        throws CoreException
        
    {
        validateClasspathEdit( project );
        convertLegacyMetadata( project );
        
        final List<IClasspathEntry> cp = getProjectClasspath( project );
        boolean cpchanged = false;
        
        for( ListIterator<IClasspathEntry> itr = cp.listIterator(); itr.hasNext(); )
        {
            final IClasspathEntry cpe = itr.next();
            final Set<Object> owners = getOwners( project, cpe );
            
            if( owners.remove( facet ) )
            {
                if( owners.size() == 0 )
                {
                    itr.remove();
                }
                else
                {
                    itr.set( setOwners( cpe, owners ) );
                }
                
                cpchanged = true;
            }
        }

        if( cpchanged )
        {
            setProjectClasspath( project, cp );
        }
    }

    public static void removeClasspathEntries( final IProject project,
                                               final IProjectFacet facet,
                                               final List<IClasspathEntry> cpentries )
    
        throws CoreException
        
    {
        final IJavaProject jproj = JavaCore.create( project );
        removeClasspathEntries( jproj, facet, cpentries );
    }
        
    public static void removeClasspathEntries( final IJavaProject project,
                                               final IProjectFacet facet,
                                               final List<IClasspathEntry> cpentries )
    
        throws CoreException
        
    {
        validateClasspathEdit( project );
        convertLegacyMetadata( project );
        
        final List<IClasspathEntry> cp = getProjectClasspath( project );
        boolean cpchanged = false;
        
        for( ListIterator<IClasspathEntry> itr = cp.listIterator(); itr.hasNext(); )
        {
            final IClasspathEntry cpe = itr.next();
            
            if( cpentries.contains( cpe ) )
            {
                final Set<Object> owners = getOwners( project, cpe );
                
                if( owners.remove( facet ) )
                {
                    if( owners.size() == 0 )
                    {
                        itr.remove();
                    }
                    else
                    {
                        itr.set( setOwners( cpe, owners ) );
                    }
                    
                    cpchanged = true;
                }
            }
        }

        if( cpchanged )
        {
            setProjectClasspath( project, cp );
        }
    }
    
    private static Set<Object> getOwners( final IJavaProject project,
                                          final IClasspathEntry cpe )
                                          
        throws CoreException
        
    {
        final Set<Object> owners = new HashSet<Object>();
        
        if( cpe != null )
        {
            for( IClasspathAttribute attr : cpe.getExtraAttributes() )
            {
                if( attr.getName().equals( OWNER_PROJECT_FACETS_ATTR ) )
                {
                    owners.addAll( decodeOwnersString( attr.getValue() ) );
                    break;
                }
            }
            
            owners.addAll( getOwnersFromLegacyMetadata( project, cpe ) );
            
            if( owners.isEmpty() )
            {
                owners.add( SYSTEM_OWNER );
            }
        }
        
        return owners;
    }

    private static Set<Object> getOwnersFromLegacyMetadata( final IJavaProject project,
                                                            final IClasspathEntry cpe )
    
        throws CoreException
        
    {
        final IProject pj = project.getProject();
        final IFile legacyMetadataFile = pj.getFile( LEGACY_METADATA_FILE_NAME );
        
        if( legacyMetadataFile.exists() )
        {
            final ProjectScope scope = new ProjectScope( pj );
            final IEclipsePreferences pluginRoot = scope.getNode( FacetCorePlugin.PLUGIN_ID );
            final Preferences root = pluginRoot.node( "classpath.helper" ); //$NON-NLS-1$
            
            final String[] keys;
            
            try
            {
                keys = root.childrenNames();
            }
            catch( BackingStoreException e )
            {
                throw new CoreException( FacetCorePlugin.createErrorStatus( e.getMessage(), e ) );
            }
            
            for( String key : keys )
            {
                final Preferences node = root.node( key );
                final String owners = node.get( "owners", null ); //$NON-NLS-1$
                
                if( owners != null )
                {
                    final IPath path = new Path( key.replaceAll( "::", "/" ) ); //$NON-NLS-1$ //$NON-NLS-2$
                    
                    if( cpe.getPath().equals( path ) )
                    {
                        return decodeOwnersString( owners );
                    }
                }
            }
        }
        
        return Collections.emptySet();
    }

    private static IClasspathEntry setOwners( final IClasspathEntry cpe,
                                              final Set<Object> owners )
    {
        if( owners.size() == 1 && owners.iterator().next() == SYSTEM_OWNER )
        {
            owners.clear();
        }
        
        final String ownersString = ( owners.size() == 0 ? null : encodeOwnersString( owners ) );
        return setOwners( cpe, ownersString );
    }

    private static IClasspathEntry setOwners( final IClasspathEntry cpe,
                                              final String owners )
    {
        final List<IClasspathAttribute> attrs = new ArrayList<IClasspathAttribute>();
        
        for( IClasspathAttribute attr : cpe.getExtraAttributes() )
        {
            if( ! attr.getName().equals( OWNER_PROJECT_FACETS_ATTR ) )
            {
                attrs.add( attr );
            }
        }
        
        if( owners != null )
        {
            attrs.add( JavaCore.newClasspathAttribute( OWNER_PROJECT_FACETS_ATTR, owners ) );
        }
        
        return new ClasspathEntry( cpe.getContentKind(), cpe.getEntryKind(), cpe.getPath(),
                                   cpe.getInclusionPatterns(), cpe.getExclusionPatterns(),
                                   cpe.getSourceAttachmentPath(), cpe.getSourceAttachmentRootPath(),
                                   cpe.getOutputLocation(), cpe.isExported(), cpe.getAccessRules(),
                                   cpe.combineAccessRules(), 
                                   attrs.toArray( new IClasspathAttribute[ attrs.size() ] ) );
    }

    private static String encodeOwnersString( final Set<Object> owners )
    {
        final StringBuilder buf = new StringBuilder();
        
        for( Object owner : owners )
        {
            if( buf.length() > 0 ) 
            {
                buf.append( ';' );
            }
            
            if( owner == SYSTEM_OWNER )
            {
                buf.append( "#system#" ); //$NON-NLS-1$
            }
            else
            {
                final IProjectFacet facet = (IProjectFacet) owner;
                buf.append( facet.getId() );
            }
        }
        
        return buf.toString();
    }
    
    private static Set<Object> decodeOwnersString( final String str )
    {
        final Set<Object> owners = new HashSet<Object>();
        final String[] split = str.split( ";" ); //$NON-NLS-1$
        
        for( int j = 0; j < split.length; j++ )
        {
            final String segment = split[ j ];
            
            if( segment.equals( "#system#" ) ) //$NON-NLS-1$
            {
                owners.add( SYSTEM_OWNER );
            }
            else
            {
                String facetId = segment;
                final int colon = facetId.indexOf( ':' );
                
                if( colon != -1 )
                {
                    facetId = facetId.substring( 0, colon );
                }
                
                owners.add( ProjectFacetsManager.getProjectFacet( facetId ) );
            }
        }
        
        return owners;
    }
    
    private static void convertLegacyMetadata( final IJavaProject project )
    
        throws CoreException
        
    {
        final IProject pj = project.getProject();
        final IFile legacyMetadataFile = pj.getFile( LEGACY_METADATA_FILE_NAME );
        
        if( legacyMetadataFile.exists() )
        {
            final ProjectScope scope = new ProjectScope( pj );
            final IEclipsePreferences pluginRoot = scope.getNode( FacetCorePlugin.PLUGIN_ID );
            final Preferences root = pluginRoot.node( "classpath.helper" ); //$NON-NLS-1$
            final Map<IPath,String> metadata = new HashMap<IPath,String>();
            
            final String[] keys;
            
            try
            {
                keys = root.childrenNames();
            }
            catch( BackingStoreException e )
            {
                throw new CoreException( FacetCorePlugin.createErrorStatus( e.getMessage(), e ) );
            }
            
            for( String key : keys )
            {
                final Preferences node = root.node( key );
                final String owners = node.get( "owners", null ); //$NON-NLS-1$
                
                if( owners != null )
                {
                    metadata.put( new Path( key.replaceAll( "::", "/" ) ), owners ); //$NON-NLS-1$ //$NON-NLS-2$
                }
            }
            
            if( ! metadata.isEmpty() )
            {
                final List<IClasspathEntry> cp = getProjectClasspath( project );
                boolean cpchanged = false;
                
                for( ListIterator<IClasspathEntry> itr = cp.listIterator(); itr.hasNext(); )
                {
                    final IClasspathEntry cpe = itr.next();
                    final String ownersString = metadata.get( cpe.getPath() );
                    
                    if( ownersString != null )
                    {
                        final Set<Object> owners = decodeOwnersString( ownersString );
                        itr.set( setOwners( cpe, encodeOwnersString( owners ) ) );
                        cpchanged = true;
                    }
                }
                
                if( cpchanged )
                {
                    setProjectClasspath( project, cp );
                }
            }
            
            legacyMetadataFile.delete( true, null );
        }
    }
    
    private static void validateClasspathEdit( final IJavaProject jproject )
    
        throws CoreException
        
    {
        final IWorkspace ws = ResourcesPlugin.getWorkspace();
        final IProject project = jproject.getProject();
        final IStatus st = ws.validateEdit( new IFile[] { project.getFile( ".classpath" ) }, IWorkspace.VALIDATE_PROMPT ); //$NON-NLS-1$
        
        if( st.getSeverity() == IStatus.ERROR )
        {
            throw new CoreException( st );
        }
    }
    
}