/*
    * This file is a part of CAST project.
    * (c) Copyright 2007, AGH University of Science & Technology
    * https://caribou.iisg.agh.edu.pl/trac/cast
    *
    * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/legal/epl-v10.html
   */
  /*
   * File: TemplateUtil.java
   * Created: 2007-00-00
   * Author: bmilos, entrop
   * $Id: AbstractTemplateUtil.java 3266 2009-08-27 15:28:45Z tmilos $
   */
  
  package pl.edu.agh.cast.data.template;
  
  import java.io.File;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.List;
  
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.log4j.Logger;
  import org.eclipse.core.resources.IFile;
  import org.eclipse.core.resources.IProject;
  import org.eclipse.core.resources.IResource;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IPath;
  import org.xml.sax.SAXException;
  
  import pl.edu.agh.cast.data.Activator;
  import pl.edu.agh.cast.data.template.xml.TemplateXmlException;
  import pl.edu.agh.cast.data.template.xml.TemplateXmlExporter;
  import pl.edu.agh.cast.data.template.xml.TemplateXmlImporter;
  import pl.edu.agh.cast.data.util.FileIOUtil;
  import pl.edu.agh.cast.project.ProjectUtil;
  import pl.edu.agh.cast.util.Configuration;
  
  /**
   * Utility methods for the import templates.
   *
   * @author AGH CAST Team
   */
  public abstract class AbstractTemplateUtil {
  
  	private static final String DOT = "."; //$NON-NLS-1$
  
  	private static Logger log = Activator.getLogger();
  
  	/**
  	 * Returns template's project.
  	 *
  	 * @return the template's project.
  	 */
  	public static IProject getTemplatesProject() throws CoreException {
  		IPath templatesPath = null;
  		return ProjectUtil.getInstance().createProject(Configuration.TEMPLATES_PROJECT_NAME, templatesPath);
  	}
  
  	/**
  	 * Returns templates names converted to lower case.
  	 *
  	 * @return lower case template names.
  	 */
  	public static HashSet<String> getTemplateLowerCaseNames() {
  		HashSet<String> names = new HashSet<String>();
  		try {
  			IProject project = AbstractTemplateUtil.getTemplatesProject();
  			String templateExtension = Configuration.TEMPLATE_FILE_EXTENSION;
  			for (IResource resource : project.members()) {
  				String fileExtension = resource.getFileExtension();
  				if (fileExtension != null && fileExtension.equals(templateExtension)) {
  					String templFileName = resource.getName();
  					names.add(templFileName.substring(0, templFileName.lastIndexOf('.')).toLowerCase());
  				}
  			}
  			return names;
  		} catch (Exception e) {
  			log.error(e.getMessage(), e);
  			return new HashSet<String>();
  		}
  	}
  
  	/**
  	 * Retrieves a collection of valid templates.
  	 *
  	 * @return collection of valid templates
  	 */
  	public static Collection<Template> getTemplates() {
  		try {
 			IProject project = AbstractTemplateUtil.getTemplatesProject();
 			final List<Template> validTemplates = new ArrayList<Template>();
 
 			String templateExtension = Configuration.TEMPLATE_FILE_EXTENSION;
 			for (IResource resource : project.members()) {
 				String fileExtension = resource.getFileExtension();
 				if (fileExtension != null && fileExtension.equals(templateExtension)) {
 					Template newTemplate = loadFromXmlFile(resource.getName());
 					validTemplates.add(newTemplate);
 				}
 			}
 			return validTemplates;
 		} catch (Exception e) {
 			log.error(e.getMessage(), e);
 			return Collections.emptyList();
 		}
 	}
 
 	private static Template loadFromXmlFile(String fileName) throws IOException, CoreException,
 	        ParserConfigurationException, SAXException {
 
 		IProject project = AbstractTemplateUtil.getTemplatesProject();
 		IFile ifile = project.getFile(fileName);
 		IPath location = ifile.getLocation();
 
 		if (location != null) {
 			File file = location.toFile();
 			TemplateXmlImporter importer = new TemplateXmlImporter();
 			Template readTempl = importer.importTemplate(file);
 			log.info("Template " + readTempl.getName() //$NON-NLS-1$
 			        + " successfully read from file: " //$NON-NLS-1$
 			        + ifile.getLocation().toString());
 			return readTempl;
 		}
 		return null;
 	}
 
 	/**
 	 * Exports and saves a given template to an XML file.
 	 *
 	 * @param template
 	 *            the template to be saved
 	 * @throws CoreException
 	 * @throws IOException
 	 */
 	public static void saveToXmlFile(Template template) throws CoreException, IOException {
 
 		IProject project = AbstractTemplateUtil.getTemplatesProject();
 		String templateFileName = template.getName() + DOT + Configuration.TEMPLATE_FILE_EXTENSION;
 		IFile ifile = project.getFile(templateFileName);
 		IPath location = ifile.getLocation();
 
 		if (location != null) {
 			File file = location.toFile();
 			TemplateXmlExporter exporter = new TemplateXmlExporter();
 			exporter.export(template, file);
 			ifile.createLink(location, IResource.NONE, null);
 
 			log.info("Template " + template.getName() //$NON-NLS-1$
 			        + " successfully saved to file: " //$NON-NLS-1$
 			        + ifile.getLocation().toString());
 		}
 	}
 
 	/**
 	 * Registers a new template from a given template file.
 	 *
 	 * @param path
 	 *            the path to file containing a template to register
 	 * @return the registered template
 	 * @throws IOException
 	 * @throws CoreException
 	 * @throws TemplateXmlException
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 */
 	public static Template registerTemplate(String path) throws IOException, CoreException, TemplateXmlException,
 	        ParserConfigurationException, SAXException {
 
 		Template template = loadTemplateFromFile(path);
 		return registerTemplate(template);
 	}
 
 	/**
 	 * Registers a new given template.
 	 *
 	 * @param template
 	 *            the template to register
 	 * @return the registered template
 	 * @throws CoreException
 	 * @throws IOException
 	 */
 	public static Template registerTemplate(Template template) throws CoreException, IOException {
 		IFile templateFile = getTemplatesProject().getFile(getTemplateFileName(template));
 		if (templateFile.exists()) {
 			return null;
 		}
 
 		saveToXmlFile(template);
 		return template;
 	}
 
 	/**
 	 * Imports and loads a new template from an XML file.
 	 *
 	 * @param path
 	 *            the path to file containing a template to be loaded
 	 * @return the loaded template
 	 * @throws SAXException
 	 * @throws ParserConfigurationException
 	 * @throws IOException
 	 */
 	public static Template loadTemplateFromFile(String path) throws SAXException, ParserConfigurationException,
 	        IOException {
 		TemplateXmlImporter importer = new TemplateXmlImporter();
 		Template template = importer.importTemplate(new File(path));
 		return template;
 	}
 
 	/**
 	 * Exports specified template to target file. It overrides target file by default.
 	 *
 	 * @param template
 	 *            the template to export
 	 * @param target
 	 *            the file where new template will be exported
 	 * @throws IOException
 	 * @throws CoreException
 	 */
 	public static void exportTemplate(Template template, File target) throws IOException, CoreException {
 		IProject project = AbstractTemplateUtil.getTemplatesProject();
 		String templateFileName = getTemplateFileName(template);
 		IFile source = project.getFile(templateFileName);
 		if (source == null) {
 			throw new FileNotFoundException("Cannot find specified template: " //$NON-NLS-1$
 			        + template.getName());
 		}
 		FileIOUtil.copyFileContent(source.getContents(), new FileOutputStream(target));
 	}
 
 	private static String getTemplateFileName(Template template) {
 		return template.getName() + DOT + Configuration.TEMPLATE_FILE_EXTENSION;
 	}
 
 }