/*
    Copyright (C) 2008 Grid Systems, S.A.
   
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
   
    This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
  
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom.components;
  
  import java.io.File;
  import java.io.IOException;
  import java.net.URI;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import javax.xml.namespace.QName;
  
  import nextgrid.api.env.ProcessEnvironment;
  import nextgrid.api.pom.Grounding;
  import nextgrid.api.pom.GroundingFactory;
  import nextgrid.api.pom.ProcessException;
  import nextgrid.api.pom.Reference;
  import nextgrid.api.pom.Service;
  
  import org.apache.commons.io.FileUtils;
  import org.apache.commons.jxpath.JXPathContext;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.gridsystems.nextgrid.api.pom.AbstractGroundingImpl;
  
  /**
   * <p>Grounding providing standard operations on the local file-system.</p>
   *
   * <h3>Usage</h3>
   *
   * <p>This grounding requires the service to be defined with the following
   * attributes:</p>
   *
   * <ul>
   *   <li><b>urn:grounding#type:</b>
   *       urn:file-system</li>
   *   <li><b>urn:grounding#operation:</b>
   *       &lt;&lt; one of the available operations &gt;&gt;</li>
   * </ul>
   *
   * <p>Convenience constants are provided for the attribute names and
   * valid values. For example, the following code creates and configures a Service
   * for the "OP_DELETE_FILE" operation:</p>
   *
   * <pre style="border:1px solid gray">
   *
   * ProcessFactory factory = ProcessFactoryFinder.getFactory();
   * Service s = factory.newServiceProcess();
   * s.setAttribute(new QName("urn:grounding", "type"), "urn:file-system");
   * s.setAttribute(new QName("urn:grounding", "operation"), "DeleteFile");
   * </pre>
   *
   * <h3>Available Operations</h3>
   *
   * <table border="1" cellspacing="0" cellpadding="1">
   *   <tr><th>Operation</th><th>Operation Name</th><th>Constant</th></tr>
   *   <tr><td>Delete File<td>DeleteFile<td>OP_DELETE_FILE
   *   <tr><td>Create File<td>CreateFileFromTemplate<td>OP_CREATE_FROM_TEMPLATE
   * </table>
   *
   * <h4>DeleteFile</h4>
   *
   * This operation deletes one or more files in the local file-system. The files
   * can be regular files or directories, either empty or not.
   * <p>
   * All input parameters are processed by this operations. Any parameter that
   * can be casted to a {@link java.io.File} instance will be deleted. For the
   * rest, if their contents in string format matches a local file path to an
   * existent file, it will be deleted.
   *
   * <h4>CreateFileFromTemplate</h4>
   *
   * <p>This operation creates a file from an optional template. It uses the
   * following inputs:</p>
   *
   * <ul>
   *   <li>Template: the first of</li>
   *   <ul>
   *     <li>Input-Parameter named 'template'
   *     <li>Attribute named 'urn:grounding#template-path' (considered as a file path)
  *     <li>Attribute named 'urn:grounding#template' (considered as the template contents)
  *   </ul>
  *   <li>Destination File: the first of</li>
  *   <ul>
  *     <li>Input-Parameter named 'dest'
  *     <li>Attribute named 'urn:grounding#dest' (considered as a file path)
  *   </ul>
  * </ul>
  *
  * <p>If no destination file is defined, a temporary file will be created.</p>
  *
  * <p>If found, the resulting file will be returned in an output parameter
  * called "file".</p>
  *
  * @author Rodrigo Ruiz
  */
 public class FileSystemGrounding extends AbstractGroundingImpl
                                  implements GroundingFactory {
 
   /**
    * Serial version UID.
    */
   private static final long serialVersionUID = 4080593507919268762L;
 
   /**
    * Map of supported attribute names and descriptions.
    */
   private static final Map<QName, String> ATTRIBS;
 
   /**
    * Class logger.
    */
   private static final Log LOG = LogFactory.getLog(FileSystemGrounding.class);
 
   /**
    * Operation that deletes a file from the file system.
    */
   public static final String OP_DELETE_FILE = "DeleteFile";
 
   /**
    * Operation that creates a file from a template.
    */
   public static final String OP_CREATE_FROM_TEMPLATE = "CreateFileFromTemplate";
 
   /**
    * Grounding type.
    */
   public static final String TYPE = "urn:file-system";
 
   /**
    * Grounding type.
    */
   public static final URI TYPE_URI = URI.create("urn:file-system");
 
   static {
     Map<QName, String> attrs = new HashMap<QName, String>();
     attrs.put(ATTR_OPERATION, "Operation name");
     ATTRIBS = Collections.unmodifiableMap(attrs);
   }
 
   /**
    * Creates a new instance.
    */
   public FileSystemGrounding() {
     super(TYPE_URI, ATTRIBS);
   }
 
   /**
    * {@inheritDoc}
    */
   public void dispose() {
   }
 
   /**
    * {@inheritDoc}
    */
   public void invoke(ProcessEnvironment env, Service service)
     throws ProcessException {
 
     String op = service.getAttribute(ATTR_OPERATION);
     if (OP_DELETE_FILE.equalsIgnoreCase(op)) {
       deleteFile(service);
     } else if (OP_CREATE_FROM_TEMPLATE.equalsIgnoreCase(op)) {
       createFromTemplate(service);
     } else {
       throw new ProcessException("Invalid operation '" + op + "'");
     }
   }
 
   /**
    * Deletes the files referenced in the specified inputs.
    *
    * @param service Service execution context
    * @throws ProcessException If an error occurs
    */
   private void deleteFile(Service service) throws ProcessException {
     Map<String, Reference<?>> inputs = service.getInputs();
 
     for (String name : inputs.keySet()) {
       Reference<?> ref = inputs.get(name);
 
       try {
         File f = toFile(ref);
 
         if (f == null) {
           LOG.warn("Skiping null file reference input '" + name + "'");
         } else {
           LOG.info("Deleting file " + f.getPath());
           FileUtils.forceDelete(f);
         }
       } catch (IOException e) {
         throw new ProcessException("Error executing grounding", e);
       }
     }
   }
 
   /**
    * Performs the actions for {@link #OP_CREATE_FROM_TEMPLATE}.
    *
    * @param service Service execution context
    * @throws ProcessException If an error occurs
    */
   private void createFromTemplate(Service service) throws ProcessException {
     try {
 
       // determine destination file
       Reference<?> refDest = service.getInput("dest");
       File dest = toFile(refDest);
       if (dest == null) {
         String path = service.getAttribute(NS_GROUNDING, "dest");
         if (path != null) {
           dest = new File(path);
         }
       }
 
       if (dest == null) {
         dest = File.createTempFile("fsg", ".tmp");
       } else if (dest.isDirectory()) {
         throw new ProcessException("Destination file is a directory");
       }
       LOG.info("Template destination: " + dest);
 
       // Determine template contents
       String template = null;
 
       Reference<?> refTemplate = service.getInput("template");
       if (refTemplate == null) {
         String path = service.getAttribute(NS_GROUNDING, "template-path");
         if (path == null) {
           template = service.getAttribute(NS_GROUNDING, "template");
         } else {
           File f = new File(path);
           if (f.isFile()) {
             template = FileUtils.readFileToString(f);
           } else {
             throw new ProcessException("Invalid template path: " + path);
           }
         }
       } else {
         if (refTemplate.canCastTo(String.class)) {
           template = (String)refTemplate.castTo(String.class);
         }
       }
 
       if (template != null && template.length() > 0) {
         String data = applyTemplate(template, service);
         FileUtils.writeStringToFile(dest, data);
       }
 
       Reference<?> output = service.getOutput("file");
       if (output != null) {
         if (output.canCastFrom(File.class)) {
           output.setValue(dest);
         } else {
           LOG.warn("Invalid output type. Output ignored.");
         }
       }
 
 
     } catch (IOException e) {
       throw new ProcessException("I/O error", e);
     }
   }
 
   /**
    * Applies variable replacements in the template, and returns the resulting
    * text.
    *
    * @param template The template to process
    * @param service  Service context
    * @return Resulting text after all replacements
    */
   private String applyTemplate(String template, Service service) {
     JXPathContext context = JXPathContext.newContext(service);
 
     String result = template;
 
     // DOTALL mode is necessary for crossing line boundaries in the template
     Pattern p = Pattern.compile(".*\\{\\{(.+)\\}\\}.*", Pattern.DOTALL);
 
     boolean changed = true;
     while (changed) {
       changed = false;
 
       Matcher m = p.matcher(result);
       if (m.matches()) {
         String expr = m.group(1);
         try {
           Object value = context.getValue(expr);
           if (value != null) {
             changed = true;
             result = result.replaceAll("\\{\\{" + expr + "\\}\\}", value.toString());
           }
         } catch (Exception e) {
           e.printStackTrace();
         }
       }
     }
     return result;
   }
 
   /**
    * Retrieves a File instance from a reference.
    *
    * @param ref The source reference
    * @return A File instance
    * @throws ProcessException If the reference cannot be translated into a File
    */
   private File toFile(Reference<?> ref) throws ProcessException {
     if (ref == null) {
       return null;
     } else if (ref.canCastTo(File.class)) {
       return (File)ref.castTo(File.class);
     } else if (ref.canCastTo(String.class)) {
       return new File((String)ref.castTo(String.class));
     } else {
       throw new ProcessException("Invalid File reference");
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public void validate() throws ProcessException {
   }
 
   /**
    * {@inheritDoc}
    */
   public Grounding createGrounding() {
     return this;
   }
 
 }