package com.niallkelly.rcp.editors;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;

import org.eclipse.core.runtime.IProduct;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPageListener;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IPartService;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.PerspectiveAdapter;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.forms.editor.FormEditor;

public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {

	private HashMap<String, ArrayList<IEditorReference>> perspectiveEditors = new HashMap<String, ArrayList<IEditorReference>>();
	private HashMap<String, IEditorReference> lastActiveEditors = new HashMap<String, IEditorReference>();
	
    public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
        super(configurer);
    }

    public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) {
        return new ApplicationActionBarAdvisor(configurer);
    }
    
    public void preWindowOpen() {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
        configurer.setInitialSize(new Point(600, 400));
        configurer.setShowCoolBar(true);
        configurer.setShowStatusLine(false);
        
		IPreferenceStore prefStore = PlatformUI.getPreferenceStore();
		prefStore.setValue(IWorkbenchPreferenceConstants.PERSPECTIVE_BAR_SIZE, "50");

        configurer.getWindow().addPageListener(new IPageListener() {
			public void pageActivated(IWorkbenchPage page) {
				updateTitle();
			}

			public void pageClosed(IWorkbenchPage page) {
				updateTitle();
			}

			public void pageOpened(IWorkbenchPage page) {
			}
		});
        
        
    	IPartService service = (IPartService) configurer.getWindow().getService(IPartService.class);
    	service.addPartListener(new IPartListener() {

			public void partActivated(IWorkbenchPart part) {
			}

			public void partBroughtToTop(IWorkbenchPart part) {
			}

			public void partClosed(IWorkbenchPart part) {
			}

			public void partDeactivated(IWorkbenchPart part) {
			}

			public void partOpened(IWorkbenchPart part) {
				if (part instanceof FormEditor) {
					FormEditor editor = (FormEditor)part;
					IWorkbenchPage page = part.getSite().getPage();
					IEditorInput editorInput = editor.getEditorInput();
					IPerspectiveDescriptor activePerspective = page.getPerspective();
					
					ArrayList<IEditorReference> editors = perspectiveEditors.get(activePerspective.getId());
					if (editors == null)
						editors = new ArrayList<IEditorReference>();

					// Find the editor reference that relates to this editor input
					IEditorReference[] editorRefs = page.findEditors(editorInput, null, IWorkbenchPage.MATCH_INPUT);
					
					if (editorRefs.length > 0) {
						editors.add(editorRefs[0]);
						perspectiveEditors.put(activePerspective.getId(), editors);
					}
				}
			}
    	});
       
		configurer.getWindow().addPerspectiveListener(new PerspectiveAdapter() {
            public void perspectiveActivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
				updateTitle();
				
				// Hide all the editors
				IEditorReference[] editors = page.getEditorReferences();
				for (int i = 0; i < editors.length; i++) {
					page.hideEditor(editors[i]);
				}
				
				// Show the editors associated with this perspective
				ArrayList<IEditorReference> editorRefs = perspectiveEditors.get(perspective.getId());
				if (editorRefs != null) {
					for (Iterator<IEditorReference> it = editorRefs.iterator(); it.hasNext(); ) {
						IEditorReference editorInput = it.next();
						page.showEditor(editorInput);
					}
					
					// Send the last active editor to the top
					IEditorReference lastActiveRef = lastActiveEditors.get(perspective.getId());
					page.bringToTop(lastActiveRef.getPart(true));
				}
			}

            public void perspectiveSavedAs(IWorkbenchPage page, IPerspectiveDescriptor oldPerspective, IPerspectiveDescriptor newPerspective) {
				updateTitle();
			}

            public void perspectiveDeactivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
				updateTitle();
				IEditorPart activeEditor = page.getActiveEditor();
				if (activeEditor != null) {

					// Find the editor reference that relates to this editor input
					IEditorReference[] editorRefs = page.findEditors(activeEditor.getEditorInput(), null, IWorkbenchPage.MATCH_INPUT);
					if (editorRefs.length > 0) {
						lastActiveEditors.put(perspective.getId(), editorRefs[0]);
					}
				}
			}
		});
	}
    
    private String computeTitle() {
		IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
		IWorkbenchPage currentPage = configurer.getWindow().getActivePage();

		String title = null;
		IProduct product = Platform.getProduct();
		if (product != null)
			title = product.getName();
		if (title == null)
			title = "";

		if (currentPage != null) {
			IPerspectiveDescriptor persp = currentPage.getPerspective();
			if (persp != null) {
				if (!persp.getLabel().equals("") && !persp.getLabel().equals(title)) //$NON-NLS-1$
					title += " - " + persp.getLabel();
			}
		}

		return title;
	}
    
	private void updateTitle() {
		IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
		String oldTitle = configurer.getTitle();
		String newTitle = computeTitle();
		if (!newTitle.equals(oldTitle))
			configurer.setTitle(newTitle);
    }
    
}