/*
    * #%L
    * Native ARchive plugin for Maven
    * %%
    * Copyright (C) 2002 - 2014 NAR Maven Plugin developers.
    * %%
    * Licensed 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.
   * #L%
   */
  package com.github.maven_nar.cpptasks.borland;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.OutputStream;
  import java.util.List;
  import java.util.Locale;
  import java.util.Map;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.xml.serialize.OutputFormat;
  import org.apache.xml.serialize.Serializer;
  import org.apache.xml.serialize.XMLSerializer;
  import org.xml.sax.ContentHandler;
  import org.xml.sax.SAXException;
  import org.xml.sax.helpers.AttributesImpl;
  
  import com.github.maven_nar.cpptasks.CCTask;
  import com.github.maven_nar.cpptasks.CUtil;
  import com.github.maven_nar.cpptasks.TargetInfo;
  import com.github.maven_nar.cpptasks.compiler.CommandLineCompilerConfiguration;
  import com.github.maven_nar.cpptasks.compiler.CommandLineLinkerConfiguration;
  import com.github.maven_nar.cpptasks.compiler.ProcessorConfiguration;
  import com.github.maven_nar.cpptasks.gcc.GccCCompiler;
  import com.github.maven_nar.cpptasks.ide.ProjectDef;
  import com.github.maven_nar.cpptasks.ide.ProjectWriter;
  
  /**
   * Writes a CBuilderX 1.0 project file.
   *
   * @author curta
   *
   */
  public final class CBuilderXProjectWriter implements ProjectWriter {
    /**
     * Utility class to generate property elements.
     */
    private static class PropertyWriter {
      /**
       * Content handler.
       */
      private final ContentHandler content;
  
      /**
       * Attributes list.
       */
      private final AttributesImpl propertyAttributes;
  
      /**
       * Constructor.
       *
       * @param contentHandler
       *          ContentHandler content handler
       */
      public PropertyWriter(final ContentHandler contentHandler) {
        this.content = contentHandler;
        this.propertyAttributes = new AttributesImpl();
        this.propertyAttributes.addAttribute(null, "category", "category", "#PCDATA", "");
        this.propertyAttributes.addAttribute(null, "name", "name", "#PCDATA", "");
        this.propertyAttributes.addAttribute(null, "value", "value", "#PCDATA", "");
      }
  
      /**
       * Write property element.
       *
       * @param category
       *          String category
       * @param name
       *          String property name
       * @param value
       *          String property value
       * @throws SAXException
       *           if I/O error or illegal content
       */
      public final void write(final String category, final String name, final String value) throws SAXException {
        this.propertyAttributes.setValue(0, category);
        this.propertyAttributes.setValue(1, name);
        this.propertyAttributes.setValue(2, value);
        this.content.startElement(null, "property", "property", this.propertyAttributes);
       this.content.endElement(null, "property", "property");
     }
   }
 
   /**
    * Constructor.
    */
   public CBuilderXProjectWriter() {
   }
 
   /**
    * Gets active platform.
    * 
    * @param task
    *          CCTask cc task
    * @return String platform identifier
    */
   private String getActivePlatform(final CCTask task) {
     final String osName = System.getProperty("os.name").toLowerCase(Locale.US);
     if (osName.contains("windows")) {
       return "win32";
     }
     return "linux";
   }
 
   /**
    * Gets the first recognized compiler from the
    * compilation targets.
    * 
    * @param targets
    *          compilation targets
    * @return representative (hopefully) compiler configuration
    */
   private CommandLineCompilerConfiguration getBaseCompilerConfiguration(final Map<String, TargetInfo> targets) {
     //
     // find first target with an gcc or bcc compilation
     //
     CommandLineCompilerConfiguration compilerConfig = null;
     //
     // get the first target and assume that it is representative
     //
     for (final TargetInfo targetInfo : targets.values()) {
       final ProcessorConfiguration config = targetInfo.getConfiguration();
       final String identifier = config.getIdentifier();
       //
       // for the first gcc or bcc compiler
       //
       if (config instanceof CommandLineCompilerConfiguration) {
         compilerConfig = (CommandLineCompilerConfiguration) config;
         if (compilerConfig.getCompiler() instanceof GccCCompiler || compilerConfig
             .getCompiler() instanceof BorlandCCompiler) {
           return compilerConfig;
         }
       }
     }
     return null;
   }
 
   /**
    * Gets build type from link target.
    * 
    * @param task
    *          CCTask current task
    * @return String build type
    */
   private String getBuildType(final CCTask task) {
     final String outType = task.getOuttype();
     if ("executable".equals(outType)) {
       return "exeproject";
     } else if ("static".equals(outType)) {
       return "libraryproject";
     }
     return "dllproject";
   }
 
   private String getWin32Toolset(final CommandLineCompilerConfiguration compilerConfig) {
     if (compilerConfig != null && compilerConfig.getCompiler() instanceof BorlandCCompiler) {
       return "win32b";
     }
     return "MinGW";
   }
 
   /**
    * Writes elements corresponding to compilation options.
    *
    * @param baseDir
    *          String base directory
    * @param writer
    *          PropertyWriter property writer
    * @param compilerConfig
    *          representative configuration
    * @throws SAXException
    *           if I/O error or illegal content
    */
   private void writeCompileOptions(final String baseDir, final PropertyWriter writer,
       final CommandLineCompilerConfiguration compilerConfig) throws SAXException {
     boolean isBcc = false;
     boolean isUnix = true;
     String compileID = "linux.Debug_Build.gnuc++.g++compile";
     if (compilerConfig.getCompiler() instanceof BorlandCCompiler) {
       compileID = "win32.Debug_Build.win32b.bcc32";
       isUnix = false;
       isBcc = true;
     }
 
     final File[] includePath = compilerConfig.getIncludePath();
     int includeIndex = 1;
     if (isUnix) {
       writer.write(compileID, "option.I.arg." + includeIndex++, "/usr/include");
       writer.write(compileID, "option.I.arg." + includeIndex++, "/usr/include/g++-3");
     }
     for (final File element : includePath) {
       final String relPath = CUtil.getRelativePath(baseDir, element);
       writer.write(compileID, "option.I.arg." + includeIndex++, relPath);
     }
     if (includePath.length > 0) {
       writer.write(compileID, "option.I.enabled", "1");
     }
 
     String defineBase = "option.D_MACRO_VALUE";
     if (isBcc) {
       defineBase = "option.D";
     }
     final String defineOption = defineBase + ".arg.";
     int defineIndex = 1;
     int undefineIndex = 1;
     final String[] preArgs = compilerConfig.getPreArguments();
     for (final String preArg : preArgs) {
       if (preArg.startsWith("-D")) {
         writer.write(compileID, defineOption + defineIndex++, preArg.substring(2));
       } else if (preArg.startsWith("-U")) {
         writer.write(compileID, "option.U.arg." + undefineIndex++, preArg.substring(2));
       } else if (!(preArg.startsWith("-I") || preArg.startsWith("-o"))) {
         //
         // any others (-g, -fno-rtti, -w, -Wall, etc)
         //
         writer.write(compileID, "option." + preArg.substring(1) + ".enabled", "1");
       }
     }
     if (defineIndex > 1) {
       writer.write(compileID, defineBase + ".enabled", "1");
     }
     if (undefineIndex > 1) {
       writer.write(compileID, "option.U.enabled", "1");
     }
   }
 
   /**
    * Writes ilink32 linker options to project file.
    *
    * @param writer
    *          PropertyWriter property writer
    * @param linkID
    *          String linker identifier
    * @param preArgs
    *          String[] linker arguments
    * @throws SAXException
    *           thrown if unable to write option
    */
   private void writeIlinkArgs(final PropertyWriter writer, final String linkID, final String[] args)
       throws SAXException {
     for (final String arg : args) {
       if (arg.charAt(0) == '/' || arg.charAt(0) == '-') {
         final int equalsPos = arg.indexOf('=');
         if (equalsPos > 0) {
           final String option = "option." + arg.substring(0, equalsPos - 1);
           writer.write(linkID, option + ".enabled", "1");
           writer.write(linkID, option + ".value", arg.substring(equalsPos + 1));
         } else {
           writer.write(linkID, "option." + arg.substring(1) + ".enabled", "1");
         }
       }
     }
   }
 
   /**
    * Writes ld linker options to project file.
    *
    * @param writer
    *          PropertyWriter property writer
    * @param linkID
    *          String linker identifier
    * @param preArgs
    *          String[] linker arguments
    * @throws SAXException
    *           thrown if unable to write option
    */
   private void writeLdArgs(final PropertyWriter writer, final String linkID, final String[] preArgs)
       throws SAXException {
     int objnameIndex = 1;
     int libnameIndex = 1;
     int libpathIndex = 1;
     for (final String preArg : preArgs) {
       if (preArg.startsWith("-o")) {
         writer.write(linkID, "option.o.arg." + objnameIndex++, preArg.substring(2));
       } else if (preArg.startsWith("-l")) {
         writer.write(linkID, "option.l.arg." + libnameIndex++, preArg.substring(2));
       } else if (preArg.startsWith("-L")) {
         writer.write(linkID, "option.L.arg." + libpathIndex++, preArg.substring(2));
       } else {
         //
         // any others
         //
         writer.write(linkID, "option." + preArg.substring(1) + ".enabled", "1");
       }
     }
     if (objnameIndex > 1) {
       writer.write(linkID, "option.o.enabled", "1");
     }
     if (libnameIndex > 1) {
       writer.write(linkID, "option.l.enabled", "1");
     }
     if (libpathIndex > 1) {
       writer.write(linkID, "option.L.enabled", "1");
     }
   }
 
   /**
    * Writes elements corresponding to link options.
    *
    * @param baseDir
    *          String base directory
    * @param writer
    *          PropertyWriter property writer
    * @param linkTarget
    *          TargetInfo link target
    * @throws SAXException
    *           if I/O error or illegal content
    */
   private void writeLinkOptions(final String baseDir, final PropertyWriter writer, final TargetInfo linkTarget)
       throws SAXException {
     if (linkTarget != null) {
       final ProcessorConfiguration config = linkTarget.getConfiguration();
       if (config instanceof CommandLineLinkerConfiguration) {
         final CommandLineLinkerConfiguration linkConfig = (CommandLineLinkerConfiguration) config;
 
         if (linkConfig.getLinker() instanceof BorlandLinker) {
           final String linkID = "win32.Debug_Build.win32b.ilink32";
           writeIlinkArgs(writer, linkID, linkConfig.getPreArguments());
           writeIlinkArgs(writer, linkID, linkConfig.getEndArguments());
           writer.write(linkID, "param.libfiles.1", "cw32mt.lib");
           writer.write(linkID, "param.libfiles.2", "import32.lib");
           int libIndex = 3;
           final String[] libNames = linkConfig.getLibraryNames();
           for (final String libName : libNames) {
             writer.write(linkID, "param.libfiles." + libIndex++, libName);
           }
           final String startup = linkConfig.getStartupObject();
           if (startup != null) {
             writer.write(linkID, "param.objfiles.1", startup);
           }
         } else {
           final String linkID = "linux.Debug_Build.gnuc++.g++link";
           writeLdArgs(writer, linkID, linkConfig.getPreArguments());
           writeLdArgs(writer, linkID, linkConfig.getEndArguments());
         }
       }
     }
   }
 
   /**
    * Writes a project definition file.
    *
    * @param fileName
    *          project name for file, should has .cbx extension
    * @param task
    *          cc task for which to write project
    * @param projectDef
    *          project element
    * @param sources
    *          source files
    * @param targets
    *          compilation targets
    * @param linkTarget
    *          link target
    * @throws IOException
    *           if I/O error
    * @throws SAXException
    *           if XML serialization error
    */
   @Override
   public void writeProject(final File fileName, final CCTask task, final ProjectDef projectDef,
       final List<File> sources, final Map<String, TargetInfo> targets, final TargetInfo linkTarget)
       throws IOException, SAXException {
 
     String projectName = projectDef.getName();
     if (projectName == null) {
       projectName = fileName.getName();
     }
     final String basePath = fileName.getAbsoluteFile().getParent();
 
     final File projectFile = new File(fileName + ".cbx");
     if (!projectDef.getOverwrite() && projectFile.exists()) {
       throw new BuildException("Not allowed to overwrite project file " + projectFile.toString());
     }
 
     final CommandLineCompilerConfiguration compilerConfig = getBaseCompilerConfiguration(targets);
     if (compilerConfig == null) {
       throw new BuildException("Unable to generate C++ BuilderX project when gcc or bcc is not used.");
     }
 
     final OutputStream outStream = new FileOutputStream(projectFile);
     final OutputFormat format = new OutputFormat("xml", "UTF-8", true);
     final Serializer serializer = new XMLSerializer(outStream, format);
     final ContentHandler content = serializer.asContentHandler();
     content.startDocument();
     final AttributesImpl emptyAttrs = new AttributesImpl();
     content.startElement(null, "project", "project", emptyAttrs);
     final PropertyWriter propertyWriter = new PropertyWriter(content);
     propertyWriter.write("build.config", "active", "0");
     propertyWriter.write("build.config", "count", "0");
     propertyWriter.write("build.config", "excludedefaultforzero", "0");
     propertyWriter.write("build.config.0", "builddir", "Debug");
     propertyWriter.write("build.config.0", "key", "Debug_Build");
     propertyWriter.write("build.config.0", "linux.builddir", "linux/Debug_Build");
     propertyWriter.write("build.config.0", "settings.MinGW", "default;debug");
     propertyWriter.write("build.config.0", "settings.gnuc++", "default;debug");
     propertyWriter.write("build.config.0", "settings.intellinia32", "default;debug");
     propertyWriter.write("build.config.0", "settings.mswin32", "default;debug");
     propertyWriter.write("build.config.0", "type", "Toolset");
     propertyWriter.write("build.config.0", "win32.builddir", "windows/Debug_Build");
     propertyWriter.write("build.node", "name", projectDef.getName());
     final String buildType = getBuildType(task);
     propertyWriter.write("build.node", "type", buildType);
     propertyWriter.write("build.platform", "active", getActivePlatform(task));
     propertyWriter.write("build.platform", "linux.Debug_Build.toolset", "gnuc++");
     propertyWriter.write("build.platform", "linux.Release_Build.toolset", "gnuc++");
     propertyWriter.write("build.platform", "linux.default", "gnuc++");
     propertyWriter.write("build.platform", "linux.gnuc++.enabled", "1");
     propertyWriter.write("build.platform", "linux.mswin32.enabled", "1");
     propertyWriter.write("build.platform", "linux.win32b.enabled", "1");
     propertyWriter.write("build.platform", "solaris.default", "gnuc++");
     propertyWriter.write("build.platform", "solaris.enabled", "1");
     final String toolset = getWin32Toolset(compilerConfig);
     propertyWriter.write("build.platform", "win32.default", toolset);
     propertyWriter.write("build.platform", "win32." + toolset + ".enabled", "1");
 
     propertyWriter.write("cbproject", "version", "X.1.0");
     if ("dllproject".equals(buildType)) {
       propertyWriter.write("gnuc++.g++compile", "option.fpic_using_GOT.enabled", "1");
       propertyWriter.write("gnuc++.g++link", "option.shared.enabled", "1");
       propertyWriter.write("intellinia32.icc", "option.minus_Kpic.enabled", "1");
       propertyWriter.write("intellinia32.icclink", "option.minus_shared.enabled", "1");
     }
     //
     // assume the first target is representative of all compilation tasks
     //
     writeCompileOptions(basePath, propertyWriter, compilerConfig);
     writeLinkOptions(basePath, propertyWriter, linkTarget);
     propertyWriter.write("linux.gnuc++.Debug_Build", "saved", "1");
     if ("dllproject".equals(buildType)) {
       propertyWriter.write("runtime", "ExcludeDefaultForZero", "1");
       // propertyWriter.write("unique", "id", "852");
     } else if ("exeproject".equals(buildType)) {
       propertyWriter.write("runtime.0", "BuildTargetOnRun", "com.borland.cbuilder.build."
           + "CBProjectBuilder$ProjectBuildAction;make");
       propertyWriter.write("runtime.0", "ConfigurationName", projectDef.getName());
       propertyWriter.write("runtime.0", "RunnableType", "com.borland.cbuilder.runtime.ExecutableRunner");
     }
     final AttributesImpl fileAttributes = new AttributesImpl();
     fileAttributes.addAttribute(null, "path", "path", "#PCDATA", "");
     AttributesImpl gccAttributes = null;
     if (!"g++".equals(compilerConfig.getCommand())) {
       gccAttributes = new AttributesImpl();
       gccAttributes.addAttribute(null, "category", "category", "#PCDATA", "build.basecmd");
       gccAttributes.addAttribute(null, "name", "name", "#PCDATA", "linux.gnuc++.Debug_Build.g++_key");
       gccAttributes.addAttribute(null, "value", "value", "#PCDATA", compilerConfig.getCommand());
     }
 
     for (final TargetInfo info : targets.values()) {
       final File[] targetsources = info.getSources();
       for (final File targetsource : targetsources) {
         final String relativePath = CUtil.getRelativePath(basePath, targetsource);
         fileAttributes.setValue(0, relativePath);
         content.startElement(null, "file", "file", fileAttributes);
 
         //
         // if file ends with .c, use gcc instead of g++
         //
         if (gccAttributes != null) {
           content.startElement(null, "property", "property", gccAttributes);
           content.endElement(null, "property", "property");
         }
         content.endElement(null, "file", "file");
       }
     }
     content.endElement(null, "project", "project");
     content.endDocument();
   }
 
 }