/*******************************************************************************
 * Copyright (c) 2013 Boeing.
 * 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:
 *     Boeing - initial API and implementation
 *******************************************************************************/
package org.eclipse.osee.framework.ui.workspacebundleloader;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.channels.FileChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Platform;
import org.eclipse.osee.framework.core.operation.AbstractOperation;
import org.eclipse.osee.framework.core.operation.Operations;
import org.eclipse.osee.framework.jdk.core.util.Lib;
import org.eclipse.osee.framework.logging.OseeLog;
import org.eclipse.osee.framework.plugin.core.util.OseeData;
import org.eclipse.osee.framework.ui.workspacebundleloader.internal.Activator;
import org.eclipse.osee.framework.ui.workspacebundleloader.internal.ManagedFolderArea;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewReference;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.XMLMemento;
import org.eclipse.ui.views.IViewDescriptor;
import org.eclipse.ui.views.IViewRegistry;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.FrameworkEvent;
import org.osgi.framework.FrameworkListener;
import org.osgi.framework.FrameworkUtil;
import org.osgi.framework.wiring.FrameworkWiring;

public class WorkspaceBundleLoadCoordinator {

	private static final String TAG_VIEW = "view";
	private static final String TAG_PERSPECTIVE = "perspective";
	private static final String TAG_OTE_PRECOMPILED = "OTEPrecompiled";
	private static final String OTE_MEMENTO = "OTEMemento";
	
	private ManagedFolderArea managedFolderArea;
	private Set<String> bundlesToCheck;
	private BundleCollection managedArea = new BundleCollection();
	private FrameworkWiring wiring;
	
	public WorkspaceBundleLoadCoordinator(File temporaryBundleLocationFolder) {
		bundlesToCheck = new HashSet<>();
		this.managedFolderArea = new ManagedFolderArea(temporaryBundleLocationFolder);
		managedFolderArea.initialize();
		this.wiring = getFrameworkWiring();
		
		Thread th = new Thread(new Runnable() {
			@Override
			public void run() {
				int lastSize = 0;
				boolean extraWait = false;
				while(true){
					try {
					   if(extraWait){
					      Thread.sleep(15000);
					      extraWait = false;
					   } else {
					      Thread.sleep(5000);
					   }
					} catch (InterruptedException e) {
					}
					if(lastSize == bundlesToCheck.size()){
						if(lastSize != 0){
							if(bundlesToCheck.size() > 0){
								lastSize = 0;
								Operations.executeAsJob(new RefreshWorkspaceBundles(), false);
								try {
									Thread.sleep(1000*60); //give time to load so we don't get called twice
								} catch (InterruptedException e) {
								}
							}
						}
					} else {
					   if(bundlesToCheck.size() - lastSize > 5){
					      extraWait = true;//big import allow for extra time for file imports
					   }
						lastSize = bundlesToCheck.size();
					}
				}
			}
		});
		th.setName("OTE BundleLoad Check");
		th.setDaemon(true);
		th.start();
	}
	
	private FrameworkWiring getFrameworkWiring() {
	   FrameworkWiring frameworkWiring = null;
	   Bundle bundle = FrameworkUtil.getBundle(getClass());
      for(Bundle findit:bundle.getBundleContext().getBundles()){
         frameworkWiring = findit.adapt(FrameworkWiring.class);
         if(frameworkWiring != null){
            break;
         }
      }
      return frameworkWiring;
   }


	private class RefreshWorkspaceBundles  extends AbstractOperation  {

		public RefreshWorkspaceBundles() {
			super("Update Precompiled", Activator.BUNDLE_ID);
		}

		@Override
		protected void doWork(IProgressMonitor monitor) throws Exception {
			updateBundles(monitor);
			installLatestBundles(monitor);
		}
		
	}

	public void saveAndCloseViews(){
		PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
			@Override
			public void run() {
				saveAndCloseManagedViews(determineManagedViews(), true);
			}
		});
	}
	
	private void closeUpdatedViews(final List<BundleInfoLite> uninstallList){
		PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable(){
			@Override
			public void run() {
				saveAndCloseManagedViews(determineManagedViews(uninstallList), true);
			}
		});
	}
	
	
	public synchronized void uninstallBundles(){
	   if(managedArea.getInstalledBundles().size() > 0){
	      saveAndCloseViews();
	      for(BundleInfoLite info:managedArea.getInstalledBundles()){
	         try {
	            info.uninstall();
	         } catch (BundleException e) {
	            OseeLog.log(WorkspaceBundleLoadCoordinator.class, Level.WARNING, e);
	         }
	      }
	      if(wiring != null){
	         wiring.refreshBundles(null);
	      }
	      IWorkbench workbench = PlatformUI.getWorkbench();     
	      if (workbench != null && workbench.getActiveWorkbenchWindow() != null){
	         IViewRegistry registry = workbench.getViewRegistry();
	         forceViewRegistryReload(workbench, registry);
	      }
	      waitForViewsToBeRegistered(null);
	   }
	}

	
	private void saveAndCloseManagedViews(Set<String> managedViewIds, boolean save) {
		
		IWorkbench workbench = PlatformUI.getWorkbench();     
		if (managedArea.getInstalledBundles().size() > 0 && workbench != null){
			IWorkbenchPage page = null;
			if(PlatformUI.getWorkbench().getActiveWorkbenchWindow() == null){
				IWorkbenchWindow[] windows = workbench.getWorkbenchWindows();
				for(IWorkbenchWindow win :windows){
					page = win.getActivePage();
					if(page != null){
						break;
					} 
				}
			} else {
				page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
			}
			if(page == null){
				return;
			}
			IPerspectiveDescriptor originalPerspective = page.getPerspective();
			XMLMemento memento = XMLMemento.createWriteRoot(TAG_OTE_PRECOMPILED);
			//find the view in other perspectives
			IPerspectiveDescriptor[] pd = page.getOpenPerspectives();
			for (int i = 0; i < pd.length; i++) {
				try {
					page.setPerspective(pd[i]);
				} catch (Exception ex) {
					// Ignore, this can get an NPE in Eclipse, see bug 4454
				} 
				IMemento perspectiveMemento = null;
				try{
					perspectiveMemento = memento.createChild(TAG_PERSPECTIVE);
					perspectiveMemento.putString("id", pd[i].getId());
				} catch (Exception ex){
					//Ignore, the perspective id is invalid xml
				}
				IViewReference[] activeReferences = page.getViewReferences();
				for (IViewReference viewReference : activeReferences) {
				   int index = viewReference.getId().indexOf(":");
				   String id = null;
				   if(index>0){
				      id = viewReference.getId().substring(0, index);
				   } else {
				      id = viewReference.getId();
				   }
					if (managedViewIds.contains(id)){
						if(perspectiveMemento != null){
							try{
								IMemento viewMemento = perspectiveMemento.createChild(TAG_VIEW);
								viewMemento.putString("id", id);
								String secondaryId = viewReference.getSecondaryId();
								if(secondaryId != null){
									viewMemento.putString("secondId", secondaryId);
								}
								IWorkbenchPart part = viewReference.getPart(false);
								if(part instanceof IViewPart){
									IViewPart viewPart = (IViewPart)part;
									viewPart.saveState(viewMemento);
								}
							} catch (Exception ex){
								//Ignore, we failed during view save
							}
						}
						try{
						   page.hideView(viewReference);
						} catch (Throwable th){
						}
					}
				}
			}
			if(save){
				saveMementoToFile(memento);
			}
			page.setPerspective(originalPerspective);
		}
	}

	private Set<String> determineManagedViews() {
		return determineManagedViews(null);
	}
	
	private Set<String> determineManagedViews(List<BundleInfoLite> uninstallList){
		Set<String> managedViewIds = new HashSet<>();
		IExtensionRegistry extensionRegistry = Platform.getExtensionRegistry();
		IExtensionPoint extensionPoint = extensionRegistry.getExtensionPoint("org.eclipse.ui.views");
		IExtension[] extensions = extensionPoint.getExtensions();
		for(IExtension ex:extensions){
			String name = ex.getContributor().getName();
			if(managedArea.getByBundleName(name) != null){
				IConfigurationElement[] elements = ex.getConfigurationElements();
				for(IConfigurationElement el:elements){
					if(el.getName().equals(TAG_VIEW)){
						String id = el.getAttribute("id");
						if(id != null){
							if(uninstallList != null){
								for(BundleInfoLite infoLite:uninstallList){
									if(name.equals(infoLite.getSymbolicName())){
										managedViewIds.add(id);
										break;
									}
								}
							} else  {
								managedViewIds.add(id);
							}
						}
					}
				}
			}
		}
		return managedViewIds;
	}
	
	private boolean saveMementoToFile(XMLMemento memento) {
		File stateFile = OseeData.getFile(OTE_MEMENTO);
		if (stateFile == null) {
			return false;
		}
		try {
			FileOutputStream stream = new FileOutputStream(stateFile);
			OutputStreamWriter writer = new OutputStreamWriter(stream, "utf-8"); //$NON-NLS-1$
			memento.save(writer);
			writer.close();
		} catch (IOException e) {
			stateFile.delete();
			return false;
		}
		return true;
	}
	
	 public static void copyFile(File source, File destination) throws IOException {
	      final FileChannel in = new FileInputStream(source).getChannel();
	      try {
	         final FileChannel out;
	         if (destination.isDirectory()) {
	            out = new FileOutputStream(new File(destination, source.getName())).getChannel();
	         } else {
	            if (destination.exists()) {
	               destination.delete(); // to work around some file permission problems
	            }
	            out = new FileOutputStream(destination).getChannel();
	         }
	         try {
	            long position = 0;
	            long size = in.size();
	            while (position < size) {
	               position += in.transferTo(position, size, out);
	            }
	         } finally {
	            Lib.close(out);
	         }
	      } finally {
	         Lib.close(in);
	      }
	   }
	
	
	private List<BundleInfoLite> determineDeltasBetweenBundlesToLoad() {
		List<BundleInfoLite> bundlesToOperateOn = new ArrayList<>();
		for(String urlString:bundlesToCheck){
			try {
				URL newURL;
				try{
					newURL = new URL(urlString);
				} catch(MalformedURLException ex){
					newURL = new File(urlString).toURI().toURL();	
				}
				
				BundleInfoLite bundleInfo = new BundleInfoLite(newURL);
				List<BundleInfoLite> bundleList = managedArea.getByBundleName(bundleInfo.getSymbolicName());
				if(bundleList == null){
					bundlesToOperateOn.add(bundleInfo);
				} else {
					boolean newBundle=true;
					if(bundleList != null && bundleList.size() > 0){
						byte[] digest1 = bundleInfo.getMd5Digest();
						for(BundleInfoLite bundle:bundleList){
							byte[] digest2 = bundle.getMd5Digest();
							if (Arrays.equals(digest1, digest2)) {
								newBundle = false;
								new File(bundle.getSystemLocation().getFile()).setLastModified(System.currentTimeMillis());
							}
						}
					} 
					if(newBundle){
						bundlesToOperateOn.add(bundleInfo);
					}
				}
			} catch (MalformedURLException e) {
				OseeLog.log(WorkspaceBundleLoadCoordinator.class, Level.WARNING, e);
			} catch (IOException e) {
				OseeLog.log(WorkspaceBundleLoadCoordinator.class, Level.WARNING, e);
			}
		}
		bundlesToCheck.clear();
		return bundlesToOperateOn;
	}

	public synchronized void addBundleToCheck(String urlString){
		this.bundlesToCheck.add(urlString);
	}
	
	public synchronized void updateBundles(IProgressMonitor monitor){
		List<BundleInfoLite> deltas = determineDeltasBetweenBundlesToLoad();
		monitor.worked(Operations.calculateWork(Operations.TASK_WORK_RESOLUTION, 0.15));
		List<BundleInfoLite> bundlesToAdd = managedFolderArea.copyDeltasToManagedFolder(deltas);
		monitor.worked(Operations.calculateWork(Operations.TASK_WORK_RESOLUTION, 0.30));
		for(BundleInfoLite bundle:bundlesToAdd){
		   managedArea.add(bundle);
		}
	    monitor.worked(Operations.calculateWork(Operations.TASK_WORK_RESOLUTION, 0.05));
	}
	
	public synchronized void installLatestBundles(final IProgressMonitor subMonitor){
		final List<BundleInfoLite> bundles = managedArea.getLatestBundles();
		Collection<Bundle> bundlesToRefresh = new ArrayList<>();
		List<BundleInfoLite> uninstallListAll = new ArrayList<>();
		for(BundleInfoLite info:bundles){
			if(!info.isInstalled()){
			   List<BundleInfoLite> uninstallList = managedArea.getByBundleName(info.getSymbolicName());
			   if(uninstallList.size() > 1){
			      for(BundleInfoLite toUninstall:uninstallList){
			         if(toUninstall.isInstalled()){
			            uninstallListAll.add(toUninstall);
			         }
			      }
			   }
			}
		}
		
		closeUpdatedViews(uninstallListAll);
		for(BundleInfoLite toUninstall:uninstallListAll){
         try {
            Bundle bundle = toUninstall.uninstall();
            bundlesToRefresh.add(bundle);
         } catch (BundleException e) {
            OseeLog.log(WorkspaceBundleLoadCoordinator.class, Level.WARNING, e);
         }
      }
		
		if(wiring != null && bundlesToRefresh.size() > 0){
			final Object waitForLoad = new Object();
			wiring.refreshBundles(bundlesToRefresh, new FrameworkListener(){
				@Override
				public void frameworkEvent(FrameworkEvent event) {
					if(FrameworkEvent.PACKAGES_REFRESHED == event.getType()){
						startBundles(bundles, subMonitor);
						waitForViewsToBeRegistered(subMonitor);
						PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
							@Override
							public void run() {
								restoreStateFromMemento(subMonitor);
							}
						});
						synchronized (waitForLoad) {
							waitForLoad.notifyAll();
						}
					}
				}
			});
			synchronized (waitForLoad) {
				try {
					waitForLoad.wait(20000);
				} catch (InterruptedException e) {
				}
			}
		} else {
			startBundles(bundles, subMonitor);
			waitForViewsToBeRegistered(subMonitor);
			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable(){
				@Override
				public void run() {
					restoreStateFromMemento(subMonitor);
				}
			});
		}
	}
	
	private boolean waitForViewsToBeRegistered(IProgressMonitor monitor){
	   if(monitor != null)
	      monitor.setTaskName("Waiting for views to register.");
		for(int i = 0; i < 10; i++){
		   if(monitor != null)
		      monitor.worked(1);
			CheckViewsRegistered check = new CheckViewsRegistered();
			PlatformUI.getWorkbench().getDisplay().syncExec(check);
			if(check.isLoaded()){
				return true;
			} else {
				try {
					Thread.sleep(5000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
		return false;
	}

	private class CheckViewsRegistered implements Runnable {

		private volatile boolean isLoaded = false;
		
		@Override
		public void run() {
			IWorkbench workbench = PlatformUI.getWorkbench();     
			if (managedArea.getInstalledBundles().size() > 0 && workbench != null && workbench.getActiveWorkbenchWindow() != null){
				IViewRegistry registry = workbench.getViewRegistry();
				forceViewRegistryReload(workbench, registry);
				Set<String> managedViews = determineManagedViews();
				for(String viewId:managedViews){
					try{
						IViewDescriptor desc = registry.find(viewId);
						if(desc == null){
							return;
						}
					} catch (Exception ex){
						return;
					}
				}
				isLoaded = true;
			} else { //no workspace bundles to load, so don't wait
				isLoaded = true;
			}

		}
		
		public boolean isLoaded(){
			return isLoaded;
		}
	}
	
	@SuppressWarnings({ "rawtypes" })
   private void forceViewRegistryReload(IWorkbench workbench, IViewRegistry registry){
      try{
         Field field1 = registry.getClass().getDeclaredField("descriptors");
         Field field2 = registry.getClass().getDeclaredField("stickyDescriptors");
         Field field3 = registry.getClass().getDeclaredField("categories");
         
         field1.setAccessible(true);
         field2.setAccessible(true);
         field3.setAccessible(true);
         
         ((Map)field1.get(registry)).clear();
         ((List)field2.get(registry)).clear();
         ((Map)field3.get(registry)).clear();
         
         field1.setAccessible(false);
         field2.setAccessible(false);
         field3.setAccessible(false);
         
         Method[] methods = registry.getClass().getDeclaredMethods();
         Method method = null;
         for(Method m:methods){
            if(m.getName().equals("postConstruct")){
               method = m;
               break;
            }
         }
         if(method != null){
            boolean access = method.isAccessible();
            method.setAccessible(true);
            try{
               method.invoke(registry);
            } finally {
               method.setAccessible(access);
            }
         }
      } catch (Throwable th){
         OseeLog.log(this.getClass(), Level.SEVERE, th);
      }
   }
	

	private void restoreStateFromMemento(IProgressMonitor restore) {
		File mementoFile = OseeData.getFile(OTE_MEMENTO);
		if(mementoFile.exists()){
			try {
				IWorkbench workbench = PlatformUI.getWorkbench();     
				if (managedArea.getInstalledBundles().size() > 0 && workbench != null && workbench.getActiveWorkbenchWindow() != null){
					IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
					IPerspectiveDescriptor originalPerspective = page.getPerspective();
					IPerspectiveDescriptor[] pds = page.getOpenPerspectives();

					XMLMemento memento = XMLMemento.createReadRoot(new FileReader(mementoFile));
					IMemento[] perspectives = memento.getChildren(TAG_PERSPECTIVE);
					if(perspectives != null){
						for(IMemento perspective:perspectives){
							IMemento[] views = perspective.getChildren(TAG_VIEW);
							if(views != null && views.length > 0){
								String perspectiveId = perspective.getString("id");
								for(IPerspectiveDescriptor pd:pds){
									if(pd.getId().equals(perspectiveId)){
										page.setPerspective(pd);
										for(IMemento view:views){
											String viewId = view.getString("id");
											String secondId = view.getString("secondId");
											if(viewId != null){
												//show view
												try {
													page.showView(viewId, secondId, IWorkbenchPage.VIEW_ACTIVATE);
												} catch (PartInitException ex) {
													System.err.println("COULD NOT FIND " + viewId + ", with ID # = " + secondId);
													ex.printStackTrace();
												}
											}
										}
										break;
									}
								}
							}
						}
					}

					page.setPerspective(originalPerspective);
				}

			} catch (WorkbenchException e) {
				e.printStackTrace();
			} catch (FileNotFoundException e) {
				e.printStackTrace();
			}
		}
	}

	private void startBundles(Collection<BundleInfoLite> bundles, IProgressMonitor subMonitor){
		BundleContext context = FrameworkUtil.getBundle(this.getClass()).getBundleContext();
		subMonitor.setTaskName("Installing Bundles");
		double workPercentage = 0.50 / (bundles.size()*2);
		int workAmount = Operations.calculateWork(Operations.TASK_WORK_RESOLUTION, workPercentage);
		for(BundleInfoLite info:bundles){
			if(!info.isInstalled()){
				try {
					info.install(context);					
				} catch (BundleException e) {
				} catch (IOException e) {
				} 
			}
			subMonitor.worked(workAmount*2);
		}
		for(BundleInfoLite info:bundles){
			if(!info.isStarted()){
				try {
					info.start(context);
				} catch (BundleException e) {
				} 
			}
			subMonitor.worked(workAmount);
		}
	}

}