/*******************************************************************************

 * Copyright (c) 2004, 2005 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.rcp;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStreamReader;

import java.io.OutputStreamWriter;

import java.io.UnsupportedEncodingException;

import junit.framework.TestCase;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.widgets.Display;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.WorkbenchException;

import org.eclipse.ui.XMLMemento;

import org.eclipse.ui.application.ActionBarAdvisor;

import org.eclipse.ui.application.IActionBarConfigurer;

import org.eclipse.ui.application.IWorkbenchConfigurer;

import org.eclipse.ui.application.IWorkbenchWindowConfigurer;

import org.eclipse.ui.application.WorkbenchWindowAdvisor;

import org.eclipse.ui.internal.UIPlugin;

import org.eclipse.ui.tests.rcp.util.WorkbenchAdvisorObserver;

public class WorkbenchSaveRestoreStateTest extends TestCase {

	private static final String ADVISOR_STATE_KEY = "advisorStateKey";

	private static final String WINDOW_ADVISOR_STATE_KEY = "windowAdvisorStateKey";

	private static final String ACTIONBAR_ADVISOR_STATE_KEY = "actionBarAdvisorStateKey";

    public WorkbenchSaveRestoreStateTest(String name) {

        super(name);

    }

    private Display display = null;

    protected void setUp() throws Exception {

        super.setUp();

        assertNull(display);

		display = PlatformUI.createDisplay();

        assertNotNull(display);

    }

    protected void tearDown() throws Exception {

        assertNotNull(display);

        display.dispose();

        assertTrue(display.isDisposed());

        super.tearDown();

    }

	/**

	 * Test save/restore state lifecycle API for WorkbenchAdvisor

	 */

	public void testSaveRestoreAdvisorState() {		

		final String advisorStateData = Long.toString(System.currentTimeMillis());

		// launch workbench and save some state data

        WorkbenchAdvisorObserver wa = new WorkbenchAdvisorObserver(1) {

			IWorkbenchWindow window = null;

			public IStatus saveState (IMemento memento) {

				assertNotNull(memento);

				memento.putString(ADVISOR_STATE_KEY, advisorStateData);

				return super.saveState(memento);

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

            public void eventLoopIdle(Display d) {

                workbenchConfig.getWorkbench().restart();

            }

        };

        int code = PlatformUI.createAndRunWorkbench(display, wa);

        assertEquals(PlatformUI.RETURN_RESTART, code);

        assertFalse(display.isDisposed());

        display.dispose();

        assertTrue(display.isDisposed());

		// restore the workbench and check for state data

        display = PlatformUI.createDisplay();		

		WorkbenchAdvisorObserver wa2 = new WorkbenchAdvisorObserver(1) {

			public IStatus restoreState(IMemento memento) {

				assertNotNull(memento);

				String stateData = memento.getString(ADVISOR_STATE_KEY);

				assertNotNull(stateData);

				assertTrue(advisorStateData.equals(stateData));

				return super.restoreState(memento);

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

        };

        int code2 = PlatformUI.createAndRunWorkbench(display, wa2);

        assertEquals(PlatformUI.RETURN_OK, code2);

	}

	/**

	 * Test save/restore state lifecycle API for WorkbenchWindowAdvisor

	 */

	public void testSaveRestoreWindowState() {

		final String advisorStateData = Long.toString(System.currentTimeMillis());

		// launch workbench and save some state data

        WorkbenchAdvisorObserver wa = new WorkbenchAdvisorObserver(1) {

			IWorkbenchWindow window = null;

			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {

				return new WorkbenchWindowAdvisor(configurer) {

					public IStatus saveState(IMemento memento) {

						assertNotNull(memento);

						memento.putString(WINDOW_ADVISOR_STATE_KEY, advisorStateData);

						return super.saveState(memento);

					}

				};

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

            public void eventLoopIdle(Display d) {

                workbenchConfig.getWorkbench().restart();

            }

        };

        int code = PlatformUI.createAndRunWorkbench(display, wa);

        assertEquals(PlatformUI.RETURN_RESTART, code);

        assertFalse(display.isDisposed());

        display.dispose();

        assertTrue(display.isDisposed());

		// restore the workbench and check for state data

        display = PlatformUI.createDisplay();		

		WorkbenchAdvisorObserver wa2 = new WorkbenchAdvisorObserver(1) {

			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {

				return new WorkbenchWindowAdvisor(configurer) {

					public IStatus restoreState(IMemento memento) {

						assertNotNull(memento);

						String stateData = memento.getString(WINDOW_ADVISOR_STATE_KEY);

						assertNotNull(stateData);

						assertTrue(advisorStateData.equals(stateData));

						return super.restoreState(memento);

					}

				};

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

        };

        int code2 = PlatformUI.createAndRunWorkbench(display, wa2);

        assertEquals(PlatformUI.RETURN_OK, code2);

	}

	/**

	 * Test save/restore state lifecycle API for WorkbenchWindowAdvisor

	 */

	public void testSaveRestoreActionBarState() {

		final String advisorStateData = Long.toString(System.currentTimeMillis());

		// launch workbench and save some state data

        WorkbenchAdvisorObserver wa = new WorkbenchAdvisorObserver(1) {

			IWorkbenchWindow window = null;

			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {

				return new WorkbenchWindowAdvisor(configurer) {

					public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer1) {

						return new ActionBarAdvisor(configurer1) {

							public IStatus saveState(IMemento memento) {

								assertNotNull(memento);

								memento.putString(ACTIONBAR_ADVISOR_STATE_KEY, advisorStateData);

								return super.saveState(memento);

							}

						};

					}

				};

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

            public void eventLoopIdle(Display d) {

                workbenchConfig.getWorkbench().restart();

            }

        };

        int code = PlatformUI.createAndRunWorkbench(display, wa);

        assertEquals(PlatformUI.RETURN_RESTART, code);

        assertFalse(display.isDisposed());

        display.dispose();

        assertTrue(display.isDisposed());

		// restore the workbench and check for state data

        display = PlatformUI.createDisplay();		

		WorkbenchAdvisorObserver wa2 = new WorkbenchAdvisorObserver(1) {

			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {

				return new WorkbenchWindowAdvisor(configurer) {

					public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer1) {

						return new ActionBarAdvisor(configurer1) {

							public IStatus restoreState(IMemento memento) {

								assertNotNull(memento);

								String stateData = memento.getString(ACTIONBAR_ADVISOR_STATE_KEY);

								assertNotNull(stateData);

								assertTrue(advisorStateData.equals(stateData));

								return super.restoreState(memento);

							}

						};

					}

				};

			}

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

        };

        int code2 = PlatformUI.createAndRunWorkbench(display, wa2);

        assertEquals(PlatformUI.RETURN_OK, code2);

	}

	/**

	 * Test on-demand save/restore state API 

	 */

	public void testOnDemandSaveRestoreState() {

		// save some window state on demand

        WorkbenchAdvisorObserver wa = new WorkbenchAdvisorObserver(1) {

			IWorkbenchWindow window = null;

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

            public void eventLoopIdle(Display d) {

                workbenchConfig.getWorkbench().restart();

            }

			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {

				return new WorkbenchWindowAdvisor(configurer) {

					public void postWindowOpen() {

						File stateLocation = getStateFileLocation();

						ensureDirectoryExists(stateLocation);

						String stateFileName = stateLocation.getPath() + File.separator + "testOnDemandSaveRestoreState.xml";

					    OutputStreamWriter writer = null;

				        try {

				            writer = new OutputStreamWriter(new FileOutputStream(stateFileName),"UTF-8");

				        } catch (UnsupportedEncodingException e1) {

				            // not possible, UTF-8 is required to be implemented by all JVMs

				        } catch (FileNotFoundException e1) {

				            // creating a new file, won't happen  unless the path eclipse 

							// specifies is totally wrong, or its read-only

				        }

				        XMLMemento xmlm = XMLMemento.createWriteRoot("TestState");

						saveState(xmlm);

				        try {

				            xmlm.save(writer);

				            writer.close();

				        } catch (IOException e) {

							e.printStackTrace();

				        }

					}					

				};

			}

        };

        int code = PlatformUI.createAndRunWorkbench(display, wa);

        assertEquals(PlatformUI.RETURN_RESTART, code);

        assertFalse(display.isDisposed());

        display.dispose();

        assertTrue(display.isDisposed());

		// restore the workbench and restore a window 

		// with state data on demand

        display = PlatformUI.createDisplay();		

		WorkbenchAdvisorObserver wa2 = new WorkbenchAdvisorObserver(1) {

			public void initialize(IWorkbenchConfigurer c) {

                super.initialize(c);

                c.setSaveAndRestore(true);

            }

			public boolean openWindows() {

				File stateLocation = getStateFileLocation();

		        String stateFileName = "testOnDemandSaveRestoreState.xml";

		        File stateFile = new File(stateLocation.getPath() + File.separator + stateFileName);

		        assertTrue(stateFile.exists());

				IMemento memento = null;

		        try {

					memento = XMLMemento.createReadRoot( new InputStreamReader (

							new FileInputStream(stateFile),"UTF-8"));

		        } catch (WorkbenchException e) {

		            e.printStackTrace();

		        } catch (FileNotFoundException e) {

		            // won't happen because we already checked it exists

		        } catch (UnsupportedEncodingException e) {

		           // not possible - UTF8 is required

		        }

				assertNotNull(memento);

				IWorkbenchWindowConfigurer window = null;

				try {

					window = getWorkbenchConfigurer().restoreWorkbenchWindow(memento);	

				} catch (WorkbenchException e) {

					e.printStackTrace();

				}

				assertNotNull(window);

				return true;

			}

			public void postWindowRestore(IWorkbenchWindowConfigurer configurer) throws WorkbenchException {

				// TODO Auto-generated method stub

				super.postWindowRestore(configurer);

			}

        };

        int code2 = PlatformUI.createAndRunWorkbench(display, wa2);

        assertEquals(PlatformUI.RETURN_OK, code2);

	}

	private File getStateFileLocation() {

	    IPath path = UIPlugin.getDefault().getStateLocation();

	    StringBuffer fileName = new StringBuffer();

	    fileName.append(File.separator);

	    fileName.append("TestWorkbenchState");

	    fileName.append(File.separator);

	    File stateLocation = path.append(fileName.toString()).toFile();		

	    ensureDirectoryExists(stateLocation);

		return stateLocation;

	}

	private void ensureDirectoryExists(File directory) {

	    directory.mkdirs();

	}

}