/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2004 Sun
 * Microsystems, Inc. All Rights Reserved.
 */

package org.netbeans.modules.java.j2seproject.ui;

import java.awt.Image;
import java.awt.event.ActionEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.ResourceBundle;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import org.netbeans.api.java.platform.JavaPlatformManager;
import org.netbeans.api.java.project.JavaProjectConstants;
import org.netbeans.api.project.FileOwnerQuery;
import org.netbeans.api.project.Project;
import org.netbeans.api.project.ProjectUtils;
import org.netbeans.api.project.SourceGroup;
import org.netbeans.api.project.Sources;
import org.netbeans.modules.java.j2seproject.ui.customizer.J2SEProjectProperties;
import org.netbeans.spi.java.project.support.ui.BrokenReferencesSupport;
import org.netbeans.spi.java.project.support.ui.PackageView;
import org.netbeans.spi.project.ActionProvider;
import org.netbeans.spi.project.SubprojectProvider;
import org.netbeans.spi.project.support.ant.AntProjectHelper;
import org.netbeans.spi.project.support.ant.PropertyEvaluator;
import org.netbeans.spi.project.support.ant.ReferenceHelper;
import org.netbeans.spi.project.ui.LogicalViewProvider;
import org.netbeans.spi.project.ui.support.CommonProjectActions;
import org.netbeans.spi.project.ui.support.ProjectSensitiveActions;
import org.openide.filesystems.FileObject;
import org.openide.nodes.FilterNode;
import org.openide.util.actions.SystemAction;
import org.openide.loaders.DataFolder;
import org.openide.nodes.AbstractNode;
import org.openide.nodes.Children;
import org.openide.nodes.Node;
import org.openide.util.Lookup;
import org.openide.util.NbBundle;
import org.openide.util.RequestProcessor;
import org.openide.util.Utilities;
import org.openide.util.WeakListeners;
import org.openide.util.lookup.Lookups;

/**
 * Support for creating logical views.
 * @author Petr Hrebejk
 */
public class J2SEPhysicalViewProvider implements LogicalViewProvider {
    
    private final Project project;
    private final AntProjectHelper helper;    
    private final PropertyEvaluator evaluator;
    private final SubprojectProvider spp;
    private final ReferenceHelper resolver;
        
    public J2SEPhysicalViewProvider(Project project, AntProjectHelper helper, PropertyEvaluator evaluator, SubprojectProvider spp, ReferenceHelper resolver) {
        this.project = project;
        assert project != null;
        this.helper = helper;
        assert helper != null;
        this.evaluator = evaluator;
        assert evaluator != null;
        this.spp = spp;
        assert spp != null;
        this.resolver = resolver;
    }
        
    public Node createLogicalView() {
        return new J2SELogicalViewRootNode();
    }

    public org.openide.nodes.Node findPath( Node root, Object target ) {
        
                
        Project project = (Project)root.getLookup().lookup( Project.class );
        if ( project == null ) {
            return null;
        }
        
        if ( target instanceof FileObject ) {
            FileObject fo = (FileObject)target;
            Project owner = FileOwnerQuery.getOwner( fo );
            if ( !project.equals( owner ) ) {
                return null; // Don't waste time if project does not own the fo
            }
            
            Node[] nodes = root.getChildren().getNodes( true );
            for ( int i = 0; i < nodes.length; i++ ) {
                Node result = PackageView.findPath( nodes[i], target );
                if ( result != null ) {
                    return result;
                }
            }
        }

        return null;
    }

    private static Lookup createLookup( Project project ) {
        DataFolder rootFolder = DataFolder.findFolder( project.getProjectDirectory() );
        // XXX Remove root folder after FindAction rewrite
        return Lookups.fixed( new Object[] { project, rootFolder } );
    }

    
    // Private innerclasses ----------------------------------------------------
        
    private static final String[] BREAKABLE_PROPERTIES = new String[] {
        J2SEProjectProperties.JAVAC_CLASSPATH,  
        J2SEProjectProperties.RUN_CLASSPATH, 
        J2SEProjectProperties.DEBUG_CLASSPATH, 
        J2SEProjectProperties.RUN_TEST_CLASSPATH, 
        J2SEProjectProperties.DEBUG_TEST_CLASSPATH, 
        J2SEProjectProperties.JAVAC_TEST_CLASSPATH,
        J2SEProjectProperties.SRC_DIR,
        J2SEProjectProperties.TEST_SRC_DIR,
    };

    public static boolean hasBrokenLinks(AntProjectHelper helper, ReferenceHelper resolver) {
        return BrokenReferencesSupport.isBroken(helper, resolver, BREAKABLE_PROPERTIES, 
            new String[] {J2SEProjectProperties.JAVA_PLATFORM});
    }

    private static Image brokenProjectBadge = Utilities.loadImage( "org/netbeans/modules/java/j2seproject/ui/resources/brokenProjectBadge.gif" ); // NOI18N
    
    /** Filter node containin additional features for the J2SE physical
     */
    private final class J2SELogicalViewRootNode extends AbstractNode {

        private Image icon;
        private Lookup lookup;
        private Action brokenLinksAction;
        private boolean broken;
        
        public J2SELogicalViewRootNode() {
            super( new LogicalViewChildren( project ), Lookups.singleton(project));
            setIconBase( "org/netbeans/modules/java/j2seproject/ui/resources/j2seProject" ); // NOI18N
            setName( ProjectUtils.getInformation( project ).getDisplayName() );            
            if (hasBrokenLinks(helper, resolver)) {
                broken = true;
            }
            brokenLinksAction = new BrokenLinksAction();
        }
        
        public Image getIcon( int type ) {
            Image original = super.getIcon( type );                
            return broken ? Utilities.mergeImages(original, brokenProjectBadge, 8, 0) : original;
        }

        public Image getOpenedIcon( int type ) {
            Image original = super.getOpenedIcon(type);                
            return broken ? Utilities.mergeImages(original, brokenProjectBadge, 8, 0) : original;            
        }            

        public Action[] getActions( boolean context ) {
            return getAdditionalActions();
        }
        
        public boolean canRename() {
            return false;
        }
        
        /*
        public boolean canDestroy() {
            return true;
        }
        
        public void destroy() throws java.io.IOException {
            System.out.println("Destroy " + project.getProjectDirectory() );
            LogicalViews.closeProjectAction().actionPerformed( new ActionEvent( this, 0, "" ) );
            project.getProjectDirectory().delete();
        }        
        */

        // Private methods -------------------------------------------------            

        private Action[] getAdditionalActions() {

            ResourceBundle bundle = NbBundle.getBundle( J2SEPhysicalViewProvider.class );
            
            return new Action[] {
                CommonProjectActions.newFileAction(),
                null,                
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_BUILD, bundle.getString( "LBL_BuildAction_Name" ), null ), // NOI18N
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_REBUILD, bundle.getString( "LBL_RebuildAction_Name" ), null ), // NOI18N
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_CLEAN, bundle.getString( "LBL_CleanAction_Name" ), null ), // NOI18N
                ProjectSensitiveActions.projectCommandAction( JavaProjectConstants.COMMAND_JAVADOC, bundle.getString( "LBL_JavadocAction_Name" ), null ), // NOI18N                
                null,
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_RUN, bundle.getString( "LBL_RunAction_Name" ), null ), // NOI18N
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_DEBUG, bundle.getString( "LBL_DebugAction_Name" ), null ), // NOI18N
                ProjectSensitiveActions.projectCommandAction( ActionProvider.COMMAND_TEST, bundle.getString( "LBL_TestAction_Name" ), null ), // NOI18N
                null,
                CommonProjectActions.setAsMainProjectAction(),
                CommonProjectActions.openSubprojectsAction(),
                CommonProjectActions.closeProjectAction(),
                null,
                SystemAction.get( org.openide.actions.FindAction.class ),
                /*
                null,
                SystemAction.get( org.openide.actions.DeleteAction.class ),
                */
                null,
                SystemAction.get( org.openide.actions.ToolsAction.class ),
                null,
                (broken ? brokenLinksAction : null),
                CommonProjectActions.customizeProjectAction(),
            };

        }
        
        /** This action is created only when project has broken references.
         * Once these are resolved the action is disabled.
         */
        private class BrokenLinksAction extends AbstractAction implements PropertyChangeListener, Runnable {
            
            private RequestProcessor.Task task = null;

            private PropertyChangeListener weakPCL;
            
            public BrokenLinksAction() {
                putValue(Action.NAME, NbBundle.getMessage(J2SEPhysicalViewProvider.class, "LBL_Fix_Broken_Links_Action"));
                setEnabled(broken);
                evaluator.addPropertyChangeListener( this );
                // When evaluator fires changes that platform properties were
                // removed the platform still exists in JavaPlatformManager.
                // That's why I have to listen here also on JPM:
                weakPCL = WeakListeners.propertyChange( this, JavaPlatformManager.getDefault() );                
                JavaPlatformManager.getDefault().addPropertyChangeListener( weakPCL );
            }

            public void actionPerformed(ActionEvent e) {
                BrokenReferencesSupport.showCustomizer(helper, resolver, BREAKABLE_PROPERTIES, new String[]{J2SEProjectProperties.JAVA_PLATFORM});
                run();
            }

            public void propertyChange(PropertyChangeEvent evt) {
                // check project state whenever there was a property change
                // or change in list of platforms.
                // Coalesce changes since they can come quickly:
                if (task == null) {
                    task = RequestProcessor.getDefault().create(this);
                }
                task.schedule(100);
            }

            public synchronized void run() {
                boolean old = broken;
                broken = hasBrokenLinks(helper, resolver);
                if (old != broken) {
                    setEnabled(broken);
                    fireIconChange();
                    fireOpenedIconChange();
                }
            }

        }

    }
    
    private static final class LogicalViewChildren extends Children.Keys/**/ implements ChangeListener {
        
        private Project project;
        
        public LogicalViewChildren( Project project ) {
            this.project = project;
        }
        
        protected void addNotify() {
            super.addNotify();            
            getSources().addChangeListener( this );            
            setKeys( getKeys() );
        }
        
        protected void removeNotify() {
            setKeys(Collections.EMPTY_SET);
            getSources().removeChangeListener( this );
            super.removeNotify();
        }
        
        protected Node[] createNodes( Object key ) {
            return new Node[] { new PackageViewFilterNode( (SourceGroup)key, project ) };            
        }            
                
        public void stateChanged( ChangeEvent e ) {
            setKeys( getKeys() );
        }
        
        // Private methods -----------------------------------------------------
        
        private Collection getKeys() {
            Sources sources = getSources();
            SourceGroup[] groups = sources.getSourceGroups( JavaProjectConstants.SOURCES_TYPE_JAVA );
            return new ArrayList( Arrays.asList( groups ) );
        }
        
        private Sources getSources() {
            return ProjectUtils.getSources( project );
        }
    }
    
    /** Yet another cool filter node just to add properties action
     */
    private static class PackageViewFilterNode extends FilterNode {
        
        private String nodeName;
        private Project project;
        
        Action[] actions;
        
        public PackageViewFilterNode( SourceGroup sourceGroup, Project project ) {
            super( PackageView.createPackageView( sourceGroup ) );            
            this.project = project;
            
            if ( "${src.dir}".equals( sourceGroup.getName() ) ) {  // NOI18N
                this.nodeName = "BuildCategory/Build"; // NOI18N
            }
            else if ( "${test.src.dir}".equals( sourceGroup.getName() ) ) { // NOI18N
                this.nodeName = "BuildCategory/BuildTests"; // NOI18N
            }
                        
        }

        
        public Action[] getActions( boolean context ) {
            if ( !context ) {
                if ( actions == null ) {
                    Action superActions[] = super.getActions( context );
                    actions = new Action[ superActions.length + 2 ];
                    System.arraycopy( superActions, 0, actions, 0, superActions.length );
                    actions[superActions.length] = null;
                    actions[superActions.length + 1] = new PreselectPropertiesAction( project, nodeName );
                }

                return actions;
                
            }
            else {
                return super.getActions( context );
            }
        }
        
        
    }
    
    
    /** The special properties action 
     */
    private static class PreselectPropertiesAction extends AbstractAction {
        
        private Project project;
        private String nodeName;
        
        public PreselectPropertiesAction( Project project, String nodeName ) {
            super( NbBundle.getMessage( J2SEPhysicalViewProvider.class, "LBL_Properties_Action" ) );
            this.project = project;
            this.nodeName = nodeName;
        }
         
        public void actionPerformed( ActionEvent e ) {
            J2SECustomizerProvider cp = (J2SECustomizerProvider)project.getLookup().lookup( J2SECustomizerProvider.class );
            if ( cp != null ) {
                cp.showCustomizer( nodeName );
            }

        }
        
        
    }
    
}