/*
    * REPOWEB, repository manager.
    *
    * Terms of license - http://opensource.org/licenses/apachepl.php
    */
   package org.repoweb.action;
   import java.io.IOException;
   import java.io.InputStream;
   import java.io.StringReader;
  import java.lang.reflect.InvocationTargetException;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.TransformerException;
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.apache.struts.action.Action;
  import org.apache.struts.action.ActionError;
  import org.apache.struts.action.ActionErrors;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  import org.apache.struts.action.ActionMessage;
  import org.apache.struts.action.ActionMessages;
  import org.apache.struts.action.DynaActionForm;
  import org.repoweb.model.Artifact;
  import org.repoweb.model.BuildFailureException;
  import org.repoweb.model.Manager;
  import org.repoweb.model.UnknownArtifactException;
  import org.repoweb.pom.Project;
  import org.repoweb.pom.XMLProject;
  import org.repoweb.xml.XMLUtil;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  /***
   * Action class to edit/create a Project Object Model.
   */
  public class EditPom extends Action {
      public static final String FROM_ARTIFACT = "EditPom.FROM_ARTIFACT";
      private static final Log LOG = LogFactory.getLog(EditPom.class);
      private static final String DEPENDENCIES_AS_XML = "depenciesAsXml";
      private static final String ARTIFACT_ID = "artifactId";
      private static final String GROUP_ID = "groupId";
      private static final String CURRENT_VERSION = "currentVersion";
  
      public ActionForward execute(ActionMapping mapping, ActionForm objForm,
          HttpServletRequest request, HttpServletResponse res)
          throws IllegalAccessException, InvocationTargetException, BuildFailureException {
          Project project = new Project();
          BeanUtils.copyProperties(project, objForm);
  
          if ("get".equals(mapping.getParameter())) {
              doGetPom(request, project, objForm);
          }
          else {
              ActionErrors errors = new ActionErrors();
              checkProperty(ARTIFACT_ID, project.getArtifactId(), errors);
              checkProperty(GROUP_ID, project.getGroupId(), errors);
              checkProperty(CURRENT_VERSION, project.getCurrentVersion(), errors);
              if (!errors.isEmpty()) {
                  saveErrors(request, errors);
                  return mapping.findForward("error");
              }
  
              String depsXml = (String)((DynaActionForm)objForm).get(DEPENDENCIES_AS_XML);
              if (depsXml != null && depsXml.trim().length() != 0) {
                  addDependenciesToProject(depsXml, project);
              }
              project.setFreeContent(xmlize(project.getFreeContent()));
              Artifact pom = Manager.getRepository().buildPom(project);
  
              Artifact fromArtifact =
                  (Artifact)request.getSession().getAttribute(FROM_ARTIFACT);
              if (fromArtifact != null) {
                  request.getSession().removeAttribute(FROM_ARTIFACT);
                  return UriBeautifier.buildActionForwardTo(fromArtifact);
              }
              else {
                  request.setAttribute(FindArtifact.RESULT_ARTIFACT, pom);
              }
          }
  
          return mapping.findForward("success");
      }
  
  
      private void fillActionFormWithDefaultPom(Project project, ActionForm objForm) {
          try {
              Artifact artifact =
                  Manager.getDefaultPomRepository().getArtifact(project.getGroupId(),
                      "pom", project.getArtifactId() + ".pom");
              Project defaultPom = loadProject(artifact);
              defaultPom.setCurrentVersion(project.getCurrentVersion());
              putProjectIntoActionForm(defaultPom, objForm);
              BeanUtils.copyProperties(project, objForm);
          }
          catch (UnknownArtifactException e) {
              ; // No default available
         }
         catch (Exception error) {
             LOG.error("Should never occur error occured :)", error); // Should never occur
         }
     }
 
 
     private void addDependenciesToProject(String depsXml, Project project)
         throws BuildFailureException {
         try {
             XMLProject.dependenciesToBean(new InputSource(
                     new StringReader(xmlize(depsXml))), project);
         }
         catch (Exception error) {
             LOG.error("Unable to understand dependency tag ! : " + depsXml, error);
             throw new BuildFailureException("Unable to understand dependency tag", error);
         }
     }
 
 
     private String xmlize(String pseudoXml) {
         if (pseudoXml == null) {
             return null;
         }
         return pseudoXml.replaceAll("&lt;", "<").replaceAll("&gt;", ">");
     }
 
 
     private void doGetPom(HttpServletRequest request, Project project, ActionForm objForm) {
         try {
             Artifact art = getPomArtifact(project);
             request.setAttribute(FindArtifact.RESULT_ARTIFACT, art);
 
             Project old = loadProject(art);
             putProjectIntoActionForm(old, objForm);
         }
         catch (UnknownArtifactException e) {
             fillActionFormWithDefaultPom(project, objForm);
 
             ActionMessages messages = new ActionMessages();
             messages.add(ActionMessages.GLOBAL_MESSAGE,
                 new ActionMessage("explorer.pom.new", project.getArtifactId()));
             saveMessages(request, messages);
         }
         catch (Exception error) {
             LOG.error("Unable to retrieve POM data !", error);
             ActionErrors errors = new ActionErrors();
             errors.add(ActionErrors.GLOBAL_MESSAGE,
                 new ActionError("explorer.pom.load.error", error.getLocalizedMessage()));
             saveErrors(request, errors);
         }
     }
 
 
     private void putProjectIntoActionForm(Project old, ActionForm objForm)
         throws TransformerException, ParserConfigurationException, IllegalAccessException, 
             InvocationTargetException {
         old.setFreeContent(XMLUtil.format(old.getFreeContent()));
         ((DynaActionForm)objForm).set(DEPENDENCIES_AS_XML,
             XMLUtil.format(XMLProject.dependenciesToXml(old)));
         BeanUtils.copyProperties(objForm, old);
     }
 
 
     private Artifact getPomArtifact(Project project)
         throws UnknownArtifactException {
         return Manager.getRepository().getArtifact(project.getGroupId(), "pom",
             project.getArtifactId() + "-" + project.getCurrentVersion() + ".pom");
     }
 
 
     private Project loadProject(Artifact art)
         throws IOException, ParserConfigurationException, SAXException, 
             TransformerException {
         final InputStream stream = art.getInputStream();
         try {
             return XMLProject.toBean(new InputSource(stream));
         }
         finally {
             stream.close();
         }
     }
 
 
     private static void checkProperty(final String propName, final String propValue,
         ActionErrors errors) {
         if (isInvalid(propValue)) {
             errors.add(propName, new ActionError("explorer.pom.data.empty", propName));
         }
     }
 
 
     private static boolean isInvalid(String value) {
         return value == null || "".equals(value.trim());
     }
 }