/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.click.eclipse.ui.wizard;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;


import org.apache.click.eclipse.ClickPlugin;
import org.apache.click.eclipse.ClickUtils;
import org.apache.click.eclipse.preferences.Template;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.ide.IDE;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

/**
 * The wizard to create new click page.
 * 
 * @author Naoki Takezoe
 */
public class NewClickPageWizard extends Wizard implements INewWizard {
	
	// keys of dialog settings
	public static final String SECTION_NEW_CLICK_PAGE = "NewClickPageWizard";
	public static final String SHOULD_CREATE_HTML = "shouldCreateHTML";
	public static final String SHOULD_CREATE_CLASS = "shouldCreateClass";
	public static final String SHOULD_ADD_TO_CLICK_XML = "shouldAddToClickXML";
	public static final String SUPERCLASS = "superclass";
	
	private IStructuredSelection selection;
	private NewClickPageWizardPage page;
	private String initialPageName = null;
	private String initialClassName = null;
	private IFile[] openFiles = null;
	
	public NewClickPageWizard() {
		super();
		setNeedsProgressMonitor(true);
		setWindowTitle(ClickPlugin.getString("wizard.newPage.title"));
		
		IDialogSettings settings = ClickPlugin.getDefault().getDialogSettings();
		if(settings.getSection(SECTION_NEW_CLICK_PAGE)==null){
			IDialogSettings section = settings.addNewSection(SECTION_NEW_CLICK_PAGE);
			section.put(SHOULD_CREATE_HTML, true);
			section.put(SHOULD_CREATE_CLASS, true);
			section.put(SHOULD_ADD_TO_CLICK_XML, false);
			section.put(SUPERCLASS, "org.apache.click.Page");
		}
		setDialogSettings(settings.getSection(SECTION_NEW_CLICK_PAGE));
	}
	
	public void init(IWorkbench workbench, IStructuredSelection selection) {
		this.selection = selection;
	}
	
	public void setInitialClassName(String className){
		this.initialClassName =  className;
	}
	
	public void setInitialPageName(String pageName){
		this.initialPageName = pageName;
	}
	
	public void addPages() {
		Object element = null;
		if(selection != null){
			element = selection.getFirstElement();
		}
		page = new NewClickPageWizardPage("page1", element, 
				this.initialClassName, this.initialPageName);
		addPage(page);
	}
	
	public boolean performFinish(){
		
		final boolean shouldCreateHTML = page.shouldCreateHTML();
		final boolean shouldCreateClass = page.shouldCreateClass();
		final boolean shouldAddToClickXML = page.shouldAddToClickXML();
		final String parentFolder = page.getParentFolder();
		final String filename = page.getFilename();
		final String sourceFolder = page.getSourceFolder();
		final String packageName = page.getPackageName();
		final String className = page.getClassName();
		final String superClass = page.getSuperClass();
		final Template template = page.getTemplate();
		final IProject project = page.getProject();
		
		IDialogSettings settings = getDialogSettings();
		settings.put(SHOULD_CREATE_HTML, shouldCreateHTML);
		settings.put(SHOULD_CREATE_CLASS, shouldCreateClass);
		settings.put(SHOULD_ADD_TO_CLICK_XML, shouldAddToClickXML);
		settings.put(SUPERCLASS, superClass);
		
		IRunnableWithProgress op = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) throws InvocationTargetException {
				try {
					openFiles = doFinish(monitor, project, shouldCreateHTML, shouldCreateClass, shouldAddToClickXML,
							parentFolder, filename, sourceFolder, packageName, className, superClass, template);
				} catch (Exception e) {
					throw new InvocationTargetException(e);
				} finally {
					monitor.done();
				}
			}
		};
		try {
			getContainer().run(true, false, op);
			for(int i=0;i<openFiles.length;i++){
				IDE.openEditor(ClickUtils.getActivePage(), openFiles[i]);
			}
		} catch (PartInitException e){
			// TODO display the error message?
			ClickPlugin.log(e);
		} catch (InterruptedException e) {
			// TODO display the error message?
			ClickPlugin.log(e);
			return false;
		} catch (InvocationTargetException e) {
			// TODO display the error message?
			Throwable realException = e.getTargetException();
			ClickPlugin.log(realException);
			return false;
		}
		return true;
	}
	
	private IFile[] doFinish(IProgressMonitor monitor, IProject project,
			boolean shouldCreateHTML,boolean shouldCreateClass, boolean shouldAddToClickXML,
			String parentFolder, String filename, String sourceFolder, String packageName,
			String className, String superClass, Template template) throws Exception {
		
		List<IFile> files = new ArrayList<IFile>();
		int totalTask = 0;
		if(shouldCreateHTML){
			totalTask++;
		}
		if(shouldCreateClass){
			totalTask++;
		}
		if(shouldAddToClickXML){
			totalTask++;
		}
		monitor.beginTask(ClickPlugin.getString("wizard.newPage.progress"), totalTask);
		
		// Creates the HTML file
		if(shouldCreateHTML){
			try {
				IFile file = null;
				if(parentFolder.equals("")){
					file = project.getFile(filename);
				} else {
					IFolder folder = project.getFolder(parentFolder);
//					if(!folder.exists()){
//						folder.create(true, true, new NullProgressMonitor());
//					}
					file = folder.getFile(filename);
				}
				if(!file.exists()){
					String charset = ClickUtils.getCharset(project);
					if(charset==null){
						charset = file.getCharset();
					}
					file.create(getTemplateInputStream(template, charset), true, new NullProgressMonitor());
				}
				files.add(file);
			} finally {
				monitor.worked(1);
			}
		}
		
		// Creates the page class
		if(shouldCreateClass){
			try {
				IResource resource = project;
				if(!sourceFolder.equals("")){
					resource = project.getFolder(sourceFolder);
				}
				
				IJavaProject javaProject = JavaCore.create(project);
				IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(resource);
				IPackageFragment fragment = root.getPackageFragment(packageName);
				if(!fragment.exists()){
					root.createPackageFragment(packageName, true, new NullProgressMonitor());
					fragment = root.getPackageFragment(packageName);
				}
				ICompilationUnit unit = fragment.getCompilationUnit(className+".java");
				if(!unit.exists()){
					IFile file = (IFile)unit.getResource();
					file.create(getPageClassInputStream(template, packageName, className, superClass),
							true, new NullProgressMonitor());
					files.add(file);
				}
			} finally {
				monitor.worked(1);
			}
		}
		
		// Adds the page mapping to the click.xml
		if(shouldAddToClickXML){
			IStructuredModel model = null;
			
			String newPath = filename;
			String webAppRoot = ClickUtils.getWebAppRootFolder(project);
			if(parentFolder.startsWith(webAppRoot)){
				parentFolder = parentFolder.substring(webAppRoot.length()).replaceAll("^/|/$","");
				if(parentFolder.length() > 0){
					newPath = parentFolder + "/" + filename;
				}
			}
			
			try {
				IFile file = ClickUtils.getClickConfigFile(project);
				IModelManager manager = StructuredModelManager.getModelManager();
				model = manager.getModelForEdit(file);
				
				IDOMDocument doc = ((IDOMModel)model).getDocument();
				
				Element root  = doc.getDocumentElement();
				Element pages = null;
				NodeList list = doc.getElementsByTagName(ClickPlugin.TAG_PAGES);
				
				if(list.getLength()==0){
					pages = doc.createElement(ClickPlugin.TAG_PAGES);
					boolean inserted = false;
					NodeList children = root.getChildNodes();
					for(int i=0;i<children.getLength();i++){
						Node node = children.item(i);
						if(node instanceof Element){
							root.insertBefore(pages, node);
							inserted = true;
							break;
						}
					}
					if(!inserted){
						root.appendChild(pages);
					}
				} else {
					pages = (Element)list.item(0);
				}
				
				NodeList children = pages.getChildNodes();
				boolean found = false;
				
				String newClazz = className;
				String pagesPackage = pages.getAttribute(ClickPlugin.ATTR_PACKAGE);
				if(packageName.length()!=0){
					if(pagesPackage==null || !packageName.equals(pagesPackage)){
						newClazz = packageName + "." + className;
					}
				}
				
				for(int i=0;i<children.getLength();i++){
					Node node = children.item(i);
					if(node instanceof Element && ((Element)node).getNodeName().equals(ClickPlugin.TAG_PAGE)){
						Element page = (Element)node;
						String path  = page.getAttribute(ClickPlugin.ATTR_PATH);
						String clazz = page.getAttribute(ClickPlugin.ATTR_CLASSNAME);
						if(newPath.equals(path) && newClazz.equals(clazz)){
							found = true;
							break;
						}
					}
				}
				if(!found){
					Element page = doc.createElement(ClickPlugin.TAG_PAGE);
					page.setAttribute(ClickPlugin.ATTR_PATH, newPath);
					page.setAttribute(ClickPlugin.ATTR_CLASSNAME, newClazz);
					pages.appendChild(page);
				}
				model.save();
			} finally {
				if(model!=null){
					model.releaseFromEdit();
				}
				monitor.worked(1);
			}
		}
		
		return (IFile[])files.toArray(new IFile[files.size()]);
	}
	
	private InputStream getTemplateInputStream(Template template, String charset){
		String source = new String(template.getHtmlTemplate());
		source = source.replaceAll("\\$\\{charset\\}", charset);
		return new ByteArrayInputStream(source.getBytes());
	}
	
	private InputStream getPageClassInputStream(Template template,
			String packageName, String className, String superClass){
		
		String source = new String(template.getPageClass());
		source = source.replaceAll("\\$\\{package\\}", packageName);
		source = source.replaceAll("\\$\\{classname\\}", className);
		source = source.replaceAll("\\$\\{superclass\\}", superClass);
		
		return new ByteArrayInputStream(source.getBytes());
	}
	
}