/*
    * 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.
   */
  package com.simpligility.maven.plugins.androidndk;
  
  import com.simpligility.maven.plugins.androidndk.configuration.ArchitectureToolchainMappings;
  import com.simpligility.maven.plugins.androidndk.phase05compile.NdkBuildMojo;
  import org.apache.commons.lang3.SystemUtils;
  import org.apache.maven.plugin.MojoExecutionException;
  
  import java.io.File;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  
  /**
   * Represents an Android NDK.
   *
   * @author Johan Lindquist <johanlindquist@gmail.com>
   * @author Manfred Moser <manfred@simpligility.com>
   */
  public class AndroidNdk
  {
  
      public static final String PROPER_NDK_HOME_DIRECTORY_MESSAGE = "Please provide a proper Android NDK directory path as configuration parameter <ndk><path>...</path></ndk>"
              + " in the plugin <configuration/>. As an alternative, you may add the parameter to commandline: -Dandroid.ndk.path=... or set environment  variable "
              + NdkBuildMojo.ENV_ANDROID_NDK_HOME + ".";
  
      public static final String[] NDK_ARCHITECTURES = { "arm64-v8a", "armeabi", "armeabi-v7a", "mips", "mips64", "x86", "x86_64" };
  
      /**
       * Arm toolchain implementations.
       */
      public static final String[] ARM_TOOLCHAIN = { "arm-linux-androideabi-4.9", "arm-linux-androideabi-4.8", "arm-linux-androideabi-4.7", "arm-linux-androideabi-4.6",
              "arm-linux-androideabi-4.4.3", "arm-linux-androidabi-clang3.5", "arm-linux-androidabi-clang3.6" };
  
      /**
       * ARM 64-bit toolchain implementations.
       */
      public static final String[] ARM_64_TOOLCHAIN = { "aarch64-linux-android-4.9", "aarch64-linux-android-clang3.5", "aarch64-linux-android-clang3.6" };
  
      /**
       * x86 toolchain implementations.
       */
      public static final String[] X86_TOOLCHAIN = { "x86-4.9", "x86-4.8", "x86-4.7", "x86-4.6", "x86-4.4.3", "x86-clang3.5", "x86-clang3.6" };
  
      /**
       * x86 64-bit toolchain implementations.
       */
      public static final String[] X86_64_TOOLCHAIN = { "x86_64-4.9", "x86_64-clang3.5", "x86_64-clang3.6" };
  
      /**
       * Mips toolchain implementations.
       */
      public static final String[] MIPS_TOOLCHAIN = { "mipsel-linux-android-4.9", "mipsel-linux-android-4.8", "mipsel-linux-android-4.7", "mipsel-linux-android-4.6", "mipsel-linux-android-4.4.3",
              "mipsel-linux-android-clang3.5", "mipsel-linux-android-clang3.6" };
  
      public static final String[] MIPS_64_TOOLCHAIN = { "mips64el-linux-android-4.9", "mips64el-linux-android-clang3.5", "mips64el-linux-android-clang3.6" };
  
      /**
       * Possible locations for the gdbserver file.
       */
      private static final String[] GDB_SERVER_LOCATIONS = { "toolchains/%s/prebuilt/gdbserver", "prebuilt/%s/gdbserver/gdbserver" };
  
      /**
       * Locations of toolchains
       */
      private static final String TOOLCHAIN_LOCATION = "toolchains/%s";
  
      private final File ndkPath;
  
      public AndroidNdk( File ndkPath )
      {
          assertPathIsDirectory( ndkPath );
          this.ndkPath = ndkPath;
      }
  
      private void assertPathIsDirectory( final File path )
      {
          if ( path == null )
          {
              throw new InvalidNdkException( PROPER_NDK_HOME_DIRECTORY_MESSAGE );
          }
          if ( !path.isDirectory() )
          {
              throw new InvalidNdkException(
                      "Path \"" + path + "\" is not a directory. " + PROPER_NDK_HOME_DIRECTORY_MESSAGE );
          }
      }
 
     /**
      * Returns the complete path for the ndk-build tool, based on this NDK.
      *
      * @return the complete path as a <code>String</code>, including the tool's filename.
      */
     public String getNdkBuildPath()
     {
         if ( SystemUtils.IS_OS_WINDOWS )
         {
             return new File( ndkPath, "/ndk-build.cmd" ).getAbsolutePath();
         }
         else
         {
             return new File( ndkPath, "/ndk-build" ).getAbsolutePath();
         }
     }
 
     public File getGdbServer( String ndkArchitecture ) throws MojoExecutionException
     {
         // create a list of possible gdb server parent folder locations
         List<String> gdbServerLocations = new ArrayList<String>();
         if ( ndkArchitecture.startsWith( "arm64-v8a" ) )
         {
             gdbServerLocations.add( "android-arm64" );
             gdbServerLocations.addAll( Arrays.asList( ARM_64_TOOLCHAIN ) );
         }
         else if ( ndkArchitecture.startsWith( "arm" ) )
         {
             gdbServerLocations.add( "android-arm" );
             gdbServerLocations.addAll( Arrays.asList( ARM_TOOLCHAIN ) );
         }
         // x86_64 is before x86!
         else if ( ndkArchitecture.startsWith( "x86_64" ) )
         {
             gdbServerLocations.add( "android-x86_64" );
             gdbServerLocations.addAll( Arrays.asList( X86_TOOLCHAIN ) );
         }
         else if ( ndkArchitecture.startsWith( "x86" ) )
         {
             gdbServerLocations.add( "android-x86" );
             gdbServerLocations.addAll( Arrays.asList( X86_TOOLCHAIN ) );
         }
         else if ( ndkArchitecture.startsWith( "mips" ) )
         {
             gdbServerLocations.add( "android-mips" );
             gdbServerLocations.addAll( Arrays.asList( MIPS_TOOLCHAIN ) );
         }
 
         // check for the gdb server
         for ( String location : GDB_SERVER_LOCATIONS )
         {
             for ( String gdbServerLocation : gdbServerLocations )
             {
                 File gdbServerFile = new File( ndkPath, String.format( location, gdbServerLocation ) );
                 if ( gdbServerFile.exists() )
                 {
                     return gdbServerFile;
                 }
             }
         }
 
         //  if we got here, throw an error
         throw new MojoExecutionException( "gdbserver binary for architecture " + ndkArchitecture
                 + " does not exist, please double check the toolchain and OS used" );
     }
 
     /**
      * Retrieves, based on the architecture and possibly toolchain mappings, the toolchain for the architecture.
      * <br/>
      * <strong>Note:</strong> This method will return the <strong>default</strong> toolchain as defined by the NDK if
      * not specified in the <code>NDKArchitectureToolchainMappings</code>.
      *
      * @param ndkArchitecture                  Architecture to resolve toolchain for
      * @param architectureToolchainMappings User mappings of architecture to toolchain
      * @return Toolchain to be used for the architecture
      * @throws MojoExecutionException If a toolchain can not be resolved
      */
     public String getToolchainFromArchitecture( final String ndkArchitecture, final ArchitectureToolchainMappings architectureToolchainMappings ) throws MojoExecutionException
     {
         // arm64 is before arm!
         if ( ndkArchitecture.startsWith( "arm64-v8a" ) )
         {
             if ( architectureToolchainMappings != null )
             {
                 return architectureToolchainMappings.getArm64 ();
             }
             return findHighestSupportedToolchain( AndroidNdk.ARM_64_TOOLCHAIN );
         }
         else if ( ndkArchitecture.startsWith( "arm" ) )
         {
             if ( architectureToolchainMappings != null )
             {
                 return architectureToolchainMappings.getArmeabi();
             }
             return findHighestSupportedToolchain( AndroidNdk.ARM_TOOLCHAIN );
         }
         // x86_64 is before x86!
         else if ( ndkArchitecture.startsWith( "x86_64" ) )
         {
             if ( architectureToolchainMappings != null )
             {
                 return architectureToolchainMappings.getX8664 ();
             }
             return findHighestSupportedToolchain( AndroidNdk.X86_64_TOOLCHAIN );
         }
         else if ( ndkArchitecture.startsWith( "x86" ) )
         {
             if ( architectureToolchainMappings != null )
             {
                 return architectureToolchainMappings.getX86();
             }
             return findHighestSupportedToolchain( AndroidNdk.X86_TOOLCHAIN );
         }
         else if ( ndkArchitecture.startsWith( "mips" ) )
         {
             if ( architectureToolchainMappings != null )
             {
                 return architectureToolchainMappings.getMips();
             }
             return findHighestSupportedToolchain( AndroidNdk.MIPS_TOOLCHAIN );
         }
 
         //  if we got here, throw an error
         throw new MojoExecutionException( "Toolchain for architecture " + ndkArchitecture + " does not exist, please double check the setup" );
     }
 
     public static void validateToolchainDirectory( File toolchainDirectory ) throws MojoExecutionException
     {
         if ( !toolchainDirectory.exists() )
         {
             //  if we got here, throw an error
             throw new MojoExecutionException( "Toolchain directory " + toolchainDirectory + " does not exist" );
         }
         if ( !toolchainDirectory.canRead() )
         {
             //  if we got here, throw an error
             throw new MojoExecutionException( "Toolchain directory " + toolchainDirectory + " exist but can not be read" );
         }
     }
 
     private String findHighestSupportedToolchain( final String[] toolchains ) throws MojoExecutionException
     {
         for ( String toolchain : toolchains )
         {
             File toolchainDirectory = new File( ndkPath, String.format( TOOLCHAIN_LOCATION, toolchain ) );
             if ( toolchainDirectory.exists() )
             {
                 AndroidNdk.validateToolchainDirectory( toolchainDirectory );
                 return toolchain;
             }
         }
 
         //  if we got here, throw an error
         throw new MojoExecutionException( "No valid toolchain could be found in the " + ndkPath + "/toolchains directory" );
     }
 }