package com.aurea.maven.plugins.sonic.esb;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.net.URL;

 import java.util.ArrayList;

 import java.util.List;

 import javax.xml.xpath.XPathConstants;

 import org.apache.maven.execution.MavenSession;

 import org.apache.maven.plugin.BuildPluginManager;

 import org.apache.maven.plugin.MojoExecutionException;

 import org.apache.maven.plugin.MojoFailureException;

 import org.codehaus.plexus.util.FileUtils;

 import org.codehaus.plexus.util.xml.XmlStreamReader;

 import org.codehaus.plexus.util.xml.Xpp3Dom;

 import org.codehaus.plexus.util.xml.Xpp3DomBuilder;

 import org.codehaus.plexus.util.xml.pull.XmlPullParserException;

 import org.twdata.maven.mojoexecutor.MojoExecutor;

 import org.twdata.maven.mojoexecutor.MojoExecutor.Element;

 import com.aurea.maven.plugins.sonic.utils.FileUtilities;

 import com.aurea.maven.plugins.sonic.utils.Xpp3Utils;

 /**

  * @author Leonardo Zanivan

  *

  * @goal connect-generate

  */

 public class ConnectGenerateMojo extends AbstractESBConnectMojo {

         /**

          * The Maven PluginManager Object.

          *

          * @component

          * @required

          */

         protected BuildPluginManager pluginManager;

         /**

          * The Maven Session Object.

          *

          * @parameter default-value="${session}"

          * @required

          * @readonly

          */

         protected MavenSession session;

         /**

          * {@inheritDoc}

          */

         protected final void doExecute() throws MojoExecutionException, MojoFailureException {

                 super.doExecute();

                 generateSonicConnectClient();

         }

         /**

          * generate Sonic Connect client code for given WADL files list

          *

          * @throws MojoExecutionException

          *

          */

         protected void generateSonicConnectClient() throws MojoExecutionException {

                 if (wadlFiles == null || "".equals(wadlFiles)) {

                         return;

                 }

                 if (wadlBaseUrl == null) {

                         wadlBaseUrl = "";

                 }

                 getLog().info("Generating Sonic Connect client code for WADL files ...");

                 final String outputDir = getOutputDirectory() + "/generated/src/main/java/connect";

                 try {

                         FileUtils.deleteDirectory(outputDir);

                         new File(outputDir).mkdirs();

                 } catch (IOException e) {

                         e.printStackTrace();

                         throw new MojoExecutionException(e.getMessage(), e);

                 }

                 final String[] files = wadlFiles.split(",");

                 for (int i = 0; i < files.length; i++) {

                         final String wadl = files[i];

                         final List<MojoExecutor.Element> wadlOptions = new ArrayList<>();

                         final MojoExecutor.Element wadlOption = MojoExecutor.element(MojoExecutor.name("wadlOption"),

                                         MojoExecutor.element(MojoExecutor.name("wadl"), wadl));

                         wadlOptions.add(wadlOption);

                         final File wadlOutputDir = new File(outputDir, "wadl" + i);

                         try {

                                 MojoExecutor.executeMojo(

                                                 MojoExecutor.plugin(MojoExecutor.groupId("org.apache.cxf"),

                                                                 MojoExecutor.artifactId("cxf-wadl2java-plugin"), MojoExecutor.version("3.1.7")),

                                                 MojoExecutor.goal("wadl2java"),

                                                 MojoExecutor.configuration(new MojoExecutor.Element[] {

                                                                 MojoExecutor.element(MojoExecutor.name("sourceRoot"), wadlOutputDir.getAbsolutePath()),

                                                                 MojoExecutor.element(MojoExecutor.name("defaultOptions"),

                                                                                 MojoExecutor.element(MojoExecutor.name("packagename"), wadlPackage)),

                                                                 MojoExecutor.element(MojoExecutor.name("wadlOptions"),

                                                                                 wadlOptions.toArray(new Element[wadlOptions.size()])) }),

                                                 MojoExecutor.executionEnvironment(project, session, pluginManager));

                         } catch (final MojoExecutionException ex) {

                                 ex.printStackTrace();

                                 throw ex;

                         }

                         final String[] generatedFiles = FileUtilities.getFileList(wadlOutputDir.getAbsolutePath(), "**/*.java",

                                         null);

                         if (generatedFiles == null || generatedFiles.length == 0) {

                                 getLog().warn("No generated files found for wadl = " + wadl);

                                 continue;

                         }

                         try {

                                 String basePath = null;

                                 XmlStreamReader reader = null;

                                 final File wadlFile = new File(wadl);

                                 if (wadlFile.exists()) {

                                         reader = new XmlStreamReader(wadlFile);

                                 } else {

                                         final URL wadlUrl = new URL(wadl);

                                         reader = new XmlStreamReader(wadlUrl);

                                 }

                                 final Xpp3Dom dom = Xpp3DomBuilder.build(reader);

                                 basePath = (String) Xpp3Utils.evaluateXPath(dom, "//@base", XPathConstants.STRING);

                                 if (basePath == null) {

                                         basePath = wadlBaseUrl;

                                 } else if (!basePath.toLowerCase().startsWith("http")) {

                                         basePath = wadlBaseUrl + basePath;

                                 }

                                 for (final String f : generatedFiles) {

                                         final File javaFile = new File(wadlOutputDir, f);

                                         final String javaSource = new String(FileUtilities.readFile(javaFile.getAbsolutePath()), "UTF-8");

                                         final int classDeclaration = calculateClassStart(javaSource);

                                         if (classDeclaration < 0) {

                                                 getLog().warn("Can't find a valid class declaration for file = " + javaFile.getAbsolutePath());

                                                 continue;

                                         }

                                         final int resourceDeclaration = javaSource.indexOf("@Path");

                                         if (resourceDeclaration < 0 || resourceDeclaration > classDeclaration) {

                                                 getLog().warn(

                                                                 "Can't find a valid resource declaration (@Path) for file = "

                                                                                 + javaFile.getAbsolutePath());

                                                 continue;

                                         }

                                         final int importDeclaration = javaSource.indexOf("import javax.ws.rs.Path");

                                         if (importDeclaration < 0) {

                                                 getLog().warn(

                                                                 "Can't find a valid import declaration (javax.ws.rs.Path) for file = "

                                                                                 + javaFile.getAbsolutePath());

                                                 continue;

                                         }

                                         final StringBuilder sb = new StringBuilder();

                                         sb.append(javaSource.substring(0, importDeclaration));

                                         sb.append("import com.aurea.sonic.esb.connect.annotation.SonicConnect;\n");

                                         sb.append(javaSource.substring(importDeclaration, classDeclaration));

                                         sb.append("@SonicConnect(baseUrl = \"" + basePath + "\", client = true)\n");

                                         String classSource = javaSource.substring(classDeclaration);

                                         //FIX: "root" is a reserved method name for Connect annotation processor

                                         classSource = classSource.replace(" root(", " root_method(");

                                         //FIX: Wadl2Java (CXF Tools) generate invalid method name with period (.)

                                         classSource = classSource.replace(" application.wadl(", " application_wadl(");

                                         sb.append(classSource);

                                         try (FileOutputStream fos = new FileOutputStream(javaFile)) {

                                                 fos.write(sb.toString().getBytes());

                                         }

                                 }

                         } catch (IOException | XmlPullParserException e) {

                                 e.printStackTrace();

                                 throw new MojoExecutionException(e.getMessage(), e);

                         }

                 }

         }

         private int calculateClassStart(final String javaSource) {

                 int classDeclaration = javaSource.indexOf("public interface");

                 if (classDeclaration < 0) {

                         classDeclaration = javaSource.indexOf("public class");

                 }

                 return classDeclaration;

         }

 }