package hudson.plugins.android_emulator;

  import  hudson.Util;

  import  hudson.model.BuildListener;

  import hudson.remoting.Callable;

  import  hudson.util.ArgumentListBuilder;

  import  hudson.util.StreamCopyThread;

  import java.io.BufferedReader;

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.FileNotFoundException;

 import java.io.FileReader;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.OutputStream;

 import java.io.PrintStream;

 import java.io.PrintWriter;

 import java.io.Serializable;

 import java.util.HashMap;

 import java.util.Map;

 class EmulatorConfig implements Serializable {

     private static final long serialVersionUID = 1L;

     private String avdName;

     private AndroidPlatform osVersion;

     private ScreenDensity screenDensity;

     private ScreenResolution screenResolution;

     private String deviceLocale;

     private String sdCardSize;

     private final boolean wipeData;

     private final boolean showWindow;

     private final String commandLineOptions;

     public EmulatorConfig(String avdName, boolean wipeData, boolean showWindow, String commandLineOptions) {

         this.avdName = avdName;

         this.wipeData = wipeData;

         this.showWindow = showWindow;

         this.commandLineOptions = commandLineOptions;

     }

     public EmulatorConfig(String osVersion, String screenDensity, String screenResolution,

             String deviceLocale, String sdCardSize, boolean wipeData, boolean showWindow,

             String commandLineOptions)

                 throws IllegalArgumentException {

         if (osVersion == null || screenDensity == null || screenResolution == null) {

             throw new IllegalArgumentException("Valid OS version and screen properties must be supplied.");

         }

         // Normalise incoming variables

         int targetLength = osVersion.length();

         if (targetLength > 2 && osVersion.startsWith("\"") && osVersion.endsWith("\"")) {

             osVersion = osVersion.substring(1, targetLength - 1);

         }

         screenDensity = screenDensity.toLowerCase();

         if (screenResolution.matches("(?i)"+ Constants.REGEX_SCREEN_RESOLUTION_ALIAS)) {

             screenResolution = screenResolution.toUpperCase();

         } else if (screenResolution.matches("(?i)"+ Constants.REGEX_SCREEN_RESOLUTION)) {

             screenResolution = screenResolution.toLowerCase();

         }

         if (deviceLocale != null && deviceLocale.length() > 4) {

             deviceLocale = deviceLocale.substring(0, 2).toLowerCase() +"_"

                 + deviceLocale.substring(3).toUpperCase();

         }

         if (sdCardSize != null) {

             sdCardSize = sdCardSize.toUpperCase().replaceAll("[ B]", "");

         }

         this.osVersion = AndroidPlatform.valueOf(osVersion);

         this.screenDensity = ScreenDensity.valueOf(screenDensity);

         this.screenResolution = ScreenResolution.valueOf(screenResolution);

         this.deviceLocale = deviceLocale;

         this.sdCardSize = sdCardSize;

         this.wipeData = wipeData;

         this.showWindow = showWindow;

         this.commandLineOptions = commandLineOptions;

     }

     public static final EmulatorConfig create(String avdName, String osVersion, String screenDensity,

             String screenResolution, String deviceLocale, String sdCardSize, boolean wipeData,

             boolean showWindow, String commandLineOptions) {

         if (Util.fixEmptyAndTrim(avdName) == null) {

             return new EmulatorConfig(osVersion, screenDensity, screenResolution, deviceLocale,

                     sdCardSize, wipeData, showWindow, commandLineOptions);

         }

         return new EmulatorConfig(avdName, wipeData, showWindow, commandLineOptions);

     }

     public boolean isNamedEmulator() {

         return avdName != null && osVersion == null;

     }

     public String getAvdName() {

         if (isNamedEmulator()) {

             return avdName;

         }

        return getGeneratedAvdName();

    }

    private String getGeneratedAvdName() {

        String locale = getDeviceLocale().replace('_', '-');

        String density = screenDensity.toString();

        String resolution = screenResolution.toString();

        String platform = osVersion.getTargetName().replace(':', '_').replace(' ', '_');

        return String.format("hudson_%s_%s_%s_%s", locale, density, resolution, platform);

    }

    public AndroidPlatform getOsVersion() {

        return osVersion;

    }

    public ScreenDensity getScreenDensity() {

        return screenDensity;

    }

    public ScreenResolution getScreenResolution() {

        return screenResolution;

    }

    public String getDeviceLocale() {

        if (deviceLocale == null) {

            return Constants.DEFAULT_LOCALE;

        }

        return deviceLocale;

    }

    public String getDeviceLanguage() {

        return getDeviceLocale().substring(0, 2);

    }

    public String getDeviceCountry() {

        return getDeviceLocale().substring(3);

    }

    public String getSdCardSize() {

        return sdCardSize;

    }

    public boolean shouldWipeData() {

        return wipeData;

    }

    public boolean shouldShowWindow() {

        return showWindow;

    }

    

    public Callable<Boolean, AndroidEmulatorException> getEmulatorCreationTask(AndroidSdk androidSdk, boolean isUnix, BuildListener listener) {

        return new EmulatorCreationTask(androidSdk, isUnix, listener);

    }

    private File getAvdHome(final File homeDir) {

        return new File(homeDir, ".android/avd/");

    }

    private File getAvdDirectory(final File homeDir) {

        return new File(getAvdHome(homeDir), getAvdName() +".avd");

    }

    private Map<String,String> parseAvdConfigFile(File homeDir) throws IOException {

        File configFile = new File(getAvdDirectory(homeDir), "config.ini");

        FileReader fileReader = new FileReader(configFile);

        BufferedReader reader = new BufferedReader(fileReader);

        String line;

        Map<String,String> values = new HashMap<String,String>();

        while ((line = reader.readLine()) != null) {

            line = line.trim();

            if (line.length() == 0 || line.charAt(0) == '#') {

                continue;

            }

            String[] parts = line.split("=", 2);

            values.put(parts[0], parts[1]);

        }

        return values;

    }

    private void writeAvdConfigFile(File homeDir, Map<String,String> values) throws FileNotFoundException {

        StringBuilder sb = new StringBuilder();

        for (String key : values.keySet()) {

            sb.append(key);

            sb.append("=");

            sb.append(values.get(key));

            sb.append("\r\n");

        }

        File configFile = new File(getAvdDirectory(homeDir), "config.ini");

        PrintWriter out = new PrintWriter(configFile);

        out.print(sb.toString());

        out.flush();

        out.close();

    }

    

    public String getCommandArguments() {

        StringBuilder sb = new StringBuilder("-no-boot-anim");

        // Set basics

        if (!isNamedEmulator()) {

            sb.append(" -prop persist.sys.language=");

            sb.append(getDeviceLanguage());

            sb.append(" -prop persist.sys.country=");

            sb.append(getDeviceCountry());

        }

        sb.append(" -avd ");

        sb.append(getAvdName());

        // Options

        if (shouldWipeData()) {

            sb.append(" -wipe-data");

        }

        if (!shouldShowWindow()) {

            sb.append(" -no-window");

        }

        if (commandLineOptions != null) {

            sb.append(" ");

            sb.append(commandLineOptions);

        }

        return sb.toString();

    }

    

    private final class EmulatorCreationTask implements Callable<Boolean, AndroidEmulatorException> {

        private static final long serialVersionUID = 1L;

        private final AndroidSdk androidSdk;

        private final boolean isUnix;

        private final BuildListener listener;

        private transient PrintStream logger;

        public EmulatorCreationTask(AndroidSdk androidSdk, boolean isUnix, BuildListener listener) {

            this.androidSdk = androidSdk;

            this.isUnix = isUnix;

            this.listener = listener;

        }

        @Override

        public Boolean call() throws AndroidEmulatorException {

            if (logger == null) {

                logger = listener.getLogger();

            }

            // Locate the base directory where Android SDK data (such as AVDs) should be kept

            // From git://android.git.kernel.org/platform/external/qemu.git/android/utils/bufprint.c

            String homeDirPath = System.getenv("ANDROID_SDK_HOME");

            if (homeDirPath == null) {

                if (isUnix) {

                    homeDirPath = System.getenv("HOME");

                    if (homeDirPath == null) {

                        homeDirPath = "/tmp";

                    }

                } else {

                    // The emulator checks Win32 "CSIDL_PROFILE", which should equal USERPROFILE

                    homeDirPath = System.getenv("USERPROFILE");

                    if (homeDirPath == null) {

                        // Otherwise fall back to user.home (which should equal USERPROFILE anyway)

                        homeDirPath = System.getProperty("user.home");

                    }

                }

            }

            final File homeDir = new File(homeDirPath);

            final File avdDirectory = getAvdDirectory(homeDir);

            // Can't do anything if a named emulator doesn't exist

            if (isNamedEmulator() && !avdDirectory.exists()) {

                throw new EmulatorDiscoveryException(Messages.AVD_DOES_NOT_EXIST(avdName));

            }

            // Check whether AVD needs to be created, or whether an existing AVD needs an SD card

            boolean createSdCard = false;

            if (avdDirectory.exists()) {

                // There's nothing to do if no SD card is required, or one already exists

                File sdCardFile = new File(getAvdDirectory(homeDir), "sdcard.img");

                if (getSdCardSize() == null || sdCardFile.exists()) {

                    return true;

                }

                createSdCard = true;

                AndroidEmulator.log(logger, Messages.ADDING_SD_CARD(sdCardSize, getAvdName()));

            } else {

                AndroidEmulator.log(logger, Messages.CREATING_AVD(avdDirectory));

            }

            // We can't continue if we don't know where to find emulator images or tools

            if (!androidSdk.hasKnownRoot()) {

                throw new EmulatorCreationException(Messages.SDK_NOT_SPECIFIED());

            }

            final File sdkRoot = new File(androidSdk.getSdkRoot());

            if (!sdkRoot.exists()) {

                throw new EmulatorCreationException(Messages.SDK_NOT_FOUND(androidSdk.getSdkRoot()));

            }

            // If we're only here to create an SD card, do so and return

            if (createSdCard) {

                if (!createSdCard(homeDir)) {

                    throw new EmulatorCreationException(Messages.SD_CARD_CREATION_FAILED());

                }

                // Update the AVD config file

                Map<String, String> configValues;

                try {

                    configValues = parseAvdConfigFile(homeDir);

                    configValues.put("sdcard.size", sdCardSize);

                    writeAvdConfigFile(homeDir, configValues);

                } catch (IOException e) {

                    throw new EmulatorCreationException(Messages.AVD_CONFIG_NOT_READABLE(), e);

                }

                return true;

            }

            // Build up basic arguments to `android` command

            final StringBuilder args = new StringBuilder(100);

            args.append("create avd ");

            if (sdCardSize != null) {

                args.append("-c ");

                args.append(sdCardSize);

                args.append(" ");

            }

            args.append("-s ");

            args.append(screenResolution.getSkinName());

            args.append(" -n ");

            args.append(getAvdName());

            ArgumentListBuilder builder = Utils.getToolCommand(androidSdk, isUnix, Tool.ANDROID, args.toString());

            // Tack on quoted platform name at the end, since it can be anything

            builder.add("-t");

            builder.add(osVersion.getTargetName());

            // Run!

            boolean avdCreated = false;

            final Process process;

            try {

                ProcessBuilder procBuilder = new ProcessBuilder(builder.toList());

                process = procBuilder.start();

            } catch (IOException ex) {

                throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());

            }

            // Redirect process's stderr to a stream, for logging purposes

            ByteArrayOutputStream stderr = new ByteArrayOutputStream();

            new StreamCopyThread("", process.getErrorStream(), stderr).start();

            // Command may prompt us whether we want to further customise the AVD.

            // Just "press" Enter to continue with the selected target's defaults.

            try {

                boolean processAlive = true;

                // Block until the command outputs something (or process ends)

                final InputStream in = process.getInputStream();

                int len = in.read();

                if (len == -1) {

                    // Check whether the process has exited badly, as sometimes no output is valid.

                    // e.g. When creating an AVD with Google APIs, no user input is requested.

                    if (process.waitFor() != 0) {

                        AndroidEmulator.log(logger, Messages.AVD_CREATION_FAILED());

                        AndroidEmulator.log(logger, stderr.toString(), true);

                        throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());

                    }

                    processAlive = false;

                }

                in.close();

                // Write CRLF, if required

                if (processAlive) {

                    final OutputStream stream = process.getOutputStream();

                    stream.write('\r');

                    stream.write('\n');

                    stream.flush();

                    stream.close();

                }

                // Wait for happy ending

                if (process.waitFor() == 0) {

                    avdCreated = true;

                }

            } catch (IOException e) {

                throw new EmulatorCreationException(Messages.AVD_CREATION_ABORTED(), e);

            } catch (InterruptedException e) {

                throw new EmulatorCreationException(Messages.AVD_CREATION_INTERRUPTED(), e);

            } finally {

                process.destroy();

            }

            // For reasons unknown, the return code may not be correctly reported on Windows.

            // So check whether stderr contains failure info (useful for other platforms too).

            String errOutput = stderr.toString();

            if (errOutput.toString().contains("list targets")) {

                AndroidEmulator.log(logger, Messages.INVALID_AVD_TARGET(osVersion.getTargetName()));

                avdCreated = false;

                errOutput = null;

            }

            // Check everything went ok

            if (!avdCreated) {

                if (errOutput != null && errOutput.length() != 0) {

                    AndroidEmulator.log(logger, stderr.toString(), true);

                }

                throw new EmulatorCreationException(Messages.AVD_CREATION_FAILED());

            }

            // Parse newly-created AVD's config

            Map<String, String> configValues;

            try {

                configValues = parseAvdConfigFile(homeDir);

            } catch (IOException e) {

                throw new EmulatorCreationException(Messages.AVD_CONFIG_NOT_READABLE(), e);

            }

            // TODO: Insert/replace any hardware properties we want to override

//            configValues.put("vm.heapSize", "4");

//            configValues.put("hw.ramSize", "64");

            // Update config file

            try {

                writeAvdConfigFile(homeDir, configValues);

            } catch (IOException e) {

                throw new EmulatorCreationException(Messages.AVD_CONFIG_NOT_WRITEABLE(), e);

            }

            // Done!

            return false;

        }

        private boolean createSdCard(File homeDir) {

            // Build command: mksdcard 32M /home/foo/.android/avd/whatever.avd/sdcard.img

            final String androidCmd = Tool.MKSDCARD.getExecutable(isUnix);

            ArgumentListBuilder builder = Utils.getToolCommand(androidSdk, isUnix, Tool.ANDROID, null);

            builder.add(sdCardSize);

            builder.add(new File(getAvdDirectory(homeDir), "sdcard.img"));

            // Run!

            try {

                ProcessBuilder procBuilder = new ProcessBuilder(builder.toList());

                procBuilder.start().waitFor();

            } catch (InterruptedException ex) {

                return false;

            } catch (IOException ex) {

                return false;

            }

            return true;

        }

    }

}