/* Copyright (C) 2011 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
*/

/* This is the source code to the tiny "emulator" launcher program
 * that is in charge of starting the target-specific emulator binary
 * for a given AVD, i.e. either 'emulator-arm' or 'emulator-x86'
 *
 * This program will be replaced in the future by what is currently
 * known as 'emulator-ui', but is a good placeholder until this
 * migration is completed.
 */

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <android/utils/compiler.h>
#include <android/utils/host_bitness.h>
#include <android/utils/panic.h>
#include <android/utils/path.h>
#include <android/utils/bufprint.h>
#include <android/utils/win32_cmdline_quote.h>
#include <android/opengl/emugl_config.h>
#include <android/qt/qt_setup.h>
#include <android/avd/scanner.h>
#include <android/avd/util.h>

/* Required by android/utils/debug.h */
int android_verbose;
bool ranchu = false;

#define DEBUG 1

#if DEBUG
#  define D(...)  do { if (android_verbose) printf("emulator:" __VA_ARGS__); } while (0)
#else
#  define D(...)  do{}while(0)
#endif

/* The extension used by dynamic libraries on the host platform */
#ifdef _WIN32
#  define DLL_EXTENSION  ".dll"
#elif defined(__APPLE__)
#  define DLL_EXTENSION  ".dylib"
#else
#  define DLL_EXTENSION  ".so"
#endif

// Name of GPU emulation main library for (32-bit and 64-bit versions)
#define GLES_EMULATION_LIB    "libOpenglRender" DLL_EXTENSION
#define GLES_EMULATION_LIB64  "lib64OpenglRender" DLL_EXTENSION

/* Forward declarations */
static char* getTargetEmulatorPath(const char* progDir,
                                   bool tryCurrentPath,
                                   const char* avdArch,
                                   const int force_32bit,
                                   bool* is_64bit);

/* The execv() definition in older mingw is slightly bogus.
 * It takes a second argument of type 'const char* const*'
 * while POSIX mandates char** instead.
 *
 * To avoid compiler warnings, define the safe_execv macro
 * to perform an explicit cast with mingw.
 */
#if defined(_WIN32) && !ANDROID_GCC_PREREQ(4,4)
#  define safe_execv(_filepath,_argv)  execv((_filepath),(const char* const*)(_argv))
#else
#  define safe_execv(_filepath,_argv)  execv((_filepath),(_argv))
#endif

/* Main routine */
int main(int argc, char** argv)
{
    const char* avdName = NULL;
    char*       avdArch = NULL;
    const char* gpu = NULL;
    char*       emulatorPath;
    int         force_32bit = 0;
    bool        no_window = false;

    /* Define ANDROID_EMULATOR_DEBUG to 1 in your environment if you want to
     * see the debug messages from this launcher program.
     */
    const char* debug = getenv("ANDROID_EMULATOR_DEBUG");

    if (debug != NULL && *debug && *debug != '0')
        android_verbose = 1;

    /* Parse command-line and look for
     * 1) an avd name either in the form or '-avd <name>' or '@<name>'
     * 2) '-force-32bit' which always use 32-bit emulator on 64-bit platforms
     * 3) '-verbose', or '-debug-all' or '-debug all' to enable verbose mode.
     */
    int  nn;
    for (nn = 1; nn < argc; nn++) {
        const char* opt = argv[nn];

        if (!strcmp(opt,"-qemu"))
            break;

        if (!strcmp(opt,"-verbose") || !strcmp(opt,"-debug-all")) {
            android_verbose = 1;
        }

        if (!strcmp(opt,"-debug") && nn + 1 < argc &&
            !strcmp(argv[nn + 1], "all")) {
            android_verbose = 1;
        }

        if (!strcmp(opt,"-gpu") && nn + 1 < argc) {
            gpu = argv[nn + 1];
            nn++;
        }

        if (!strcmp(opt,"-ranchu")) {
            ranchu = true;
            continue;
        }

        if (!strcmp(opt,"-force-32bit")) {
            force_32bit = 1;
            continue;
        }

        if (!strcmp(opt,"-no-window")) {
            no_window = true;
            continue;
        }

        if (!strcmp(opt,"-list-avds")) {
            AvdScanner* scanner = avdScanner_new(NULL);
            for (;;) {
                const char* name = avdScanner_next(scanner);
                if (!name) {
                    break;
                }
                printf("%s\n", name);
            }
            avdScanner_free(scanner);
            exit(0);
        }

        if (!avdName) {
            if (!strcmp(opt,"-avd") && nn+1 < argc) {
                avdName = argv[nn+1];
            }
            else if (opt[0] == '@' && opt[1] != '\0') {
                avdName = opt+1;
            }
        }
    }

    /* If ANDROID_EMULATOR_FORCE_32BIT is set to 'true' or '1' in the
     * environment, set -force-32bit automatically.
     */
    {
        const char kEnvVar[] = "ANDROID_EMULATOR_FORCE_32BIT";
        const char* val = getenv(kEnvVar);
        if (val && (!strcmp(val, "true") || !strcmp(val, "1"))) {
            if (!force_32bit) {
                D("Auto-config: -force-32bit (%s=%s)\n", kEnvVar, val);
                force_32bit = 1;
            }
        }
    }

#if defined(__linux__)
    if (!force_32bit && android_getHostBitness() == 32) {
        fprintf(stderr,
"ERROR: 32-bit Linux Android emulator binaries are DEPRECATED, to use them\n"
"       you will have to do at least one of the following:\n"
"\n"
"       - Use the '-force-32bit' option when invoking 'emulator'.\n"
"       - Set ANDROID_EMULATOR_FORCE_32BIT to 'true' in your environment.\n"
"\n"
"       Either one will allow you to use the 32-bit binaries, but please be\n"
"       aware that these will disappear in a future Android SDK release.\n"
"       Consider moving to a 64-bit Linux system before that happens.\n"
"\n"
        );
        exit(1);
    }
#endif

    /* If there is an AVD name, we're going to extract its target architecture
     * by looking at its config.ini
     */
    if (avdName != NULL) {
        D("Found AVD name '%s'\n", avdName);
        avdArch = path_getAvdTargetArch(avdName);
        D("Found AVD target architecture: %s\n", avdArch);
    } else {
        /* Otherwise, using the ANDROID_PRODUCT_OUT directory */
        const char* androidOut = getenv("ANDROID_PRODUCT_OUT");

        if (androidOut != NULL) {
            D("Found ANDROID_PRODUCT_OUT: %s\n", androidOut);
            avdArch = path_getBuildTargetArch(androidOut);
            D("Found build target architecture: %s\n",
              avdArch ? avdArch : "<NULL>");
        }
    }

    if (avdArch == NULL) {
        avdArch = "arm";
        D("Can't determine target AVD architecture: defaulting to %s\n", avdArch);
    }

    /* Find program directory. */
    char* progDir = NULL;
    path_split(argv[0], &progDir, NULL);

    /* Only search in current path if there is no directory separator
     * in |progName|. */
#ifdef _WIN32
    bool tryCurrentPath = (!strchr(argv[0], '/') && !strchr(argv[0], '\\'));
#else
    bool tryCurrentPath = !strchr(argv[0], '/');
#endif

    /* Find the architecture-specific program in the same directory */
    bool is_64bit = false;
    emulatorPath = getTargetEmulatorPath(progDir,
                                         tryCurrentPath,
                                         avdArch,
                                         force_32bit,
                                         &is_64bit);
    D("Found target-specific emulator binary: %s\n", emulatorPath);

    /* Replace it in our command-line */
    argv[0] = emulatorPath;

    /* We need to find the location of the GLES emulation shared libraries
     * and modify either LD_LIBRARY_PATH or PATH accordingly
     */
    bool gpuEnabled = false;
    const char* gpuMode = NULL;

    if (avdName) {
        gpuMode = path_getAvdGpuMode(avdName);
        gpuEnabled = (gpuMode != NULL);
    }

    EmuglConfig config;
    int bitness = is_64bit ? 64 : 32;
    if (!emuglConfig_init(
                &config, gpuEnabled, gpuMode, gpu, bitness, no_window)) {
        fprintf(stderr, "ERROR: %s\n", config.status);
        exit(1);
    }
    D("%s\n", config.status);

    emuglConfig_setupEnv(&config);

    /* For Qt-based UI backends, add <lib>/qt/ to the library search path. */
    androidQtSetupEnv(is_64bit);

#ifdef _WIN32
    // Take care of quoting all parameters before sending them to execv().
    // See the "Eveyone quotes command line arguments the wrong way" on
    // MSDN.
    int n;
    for (n = 0; n < argc; ++n) {
        // Technically, this leaks the quoted strings, but we don't care
        // since this process will terminate after the execv() anyway.
        argv[n] = win32_cmdline_quote(argv[n]);
        D("Quoted param: [%s]\n", argv[n]);
    }
#endif

    if (android_verbose) {
        int i;
        printf("emulator: Running :%s\n", emulatorPath);
        for(i = 0; i < argc; i++) {
            printf("emulator: qemu backend: argv[%02d] = \"%s\"\n", i, argv[i]);
        }
        /* Dump final command-line parameters to make debugging easier */
        printf("emulator: Concatenated backend parameters:\n");
        for (i = 0; i < argc; i++) {
            /* To make it easier to copy-paste the output to a command-line,
             * quote anything that contains spaces.
             */
            if (strchr(argv[i], ' ') != NULL) {
                printf(" '%s'", argv[i]);
            } else {
                printf(" %s", argv[i]);
            }
        }
        printf("\n");
    }

    // Launch it with the same set of options !
    // Note that on Windows, the first argument must _not_ be quoted or
    // Windows will fail to find the program.
    safe_execv(emulatorPath, argv);

    /* We could not launch the program ! */
    fprintf(stderr, "Could not launch '%s': %s\n", emulatorPath, strerror(errno));
    return errno;
}

static char* bufprint_emulatorName(char* p,
                                   char* end,
                                   const char* progDir,
                                   const char* prefix,
                                   const char* variant,
                                   const char* archSuffix,
                                   const char* exeExtension) {
    if (progDir) {
        p = bufprint(p, end, "%s/", progDir);
    }
    p = bufprint(p, end, "%s", prefix);
    if (variant) {
        p = bufprint(p, end, "%s-", variant);
    }
    p = bufprint(p, end, "%s%s", archSuffix, exeExtension);
    return p;
}

/* Probe the filesystem to check if an emulator executable named like
 * <progDir>/<prefix><arch> exists.
 *
 * |progDir| is an optional program directory. If NULL, the executable
 * will be searched in the current directory.
 * |variant| is an optional variant. If not NULL, then a name like
 * 'emulator-<variant>-<archSuffix>' will be searched, instead of
 * 'emulator-<archSuffix>'.
 * |archSuffix| is an architecture-specific suffix, like "arm", or 'x86"
 * If |search_for_64bit_emulator| is true, lookup for 64-bit emulator first,
 * then the 32-bit version.
 * If |try_current_path|, try to look into the current path if no
 * executable was found under |progDir|.
 * On success, returns the path of the executable (string must be freed by
 * the caller) and sets |*is_64bit| to indicate whether the binary is a
 * 64-bit executable. On failure, return NULL.
 */
static char*
probeTargetEmulatorPath(const char* progDir,
                        const char* variant,
                        const char* archSuffix,
                        bool search_for_64bit_emulator,
                        bool try_current_path,
                        bool* is_64bit)
{
    char path[PATH_MAX], *pathEnd = path + sizeof(path), *p;

    static const char kEmulatorPrefix[] = "emulator-";
    static const char kEmulator64Prefix[] = "emulator64-";
#ifdef _WIN32
    const char kExeExtension[] = ".exe";
#else
    const char kExeExtension[] = "";
#endif

    // First search for the 64-bit emulator binary.
    if (search_for_64bit_emulator) {
        p = bufprint_emulatorName(path,
                                  pathEnd,
                                  progDir,
                                  kEmulator64Prefix,
                                  variant,
                                  archSuffix,
                                  kExeExtension);
        D("Probing program: %s\n", path);
        if (p < pathEnd && path_exists(path)) {
            *is_64bit = true;
            return strdup(path);
        }
    }

    // Then for the 32-bit one.
    p = bufprint_emulatorName(path,
                                pathEnd,
                                progDir,
                                kEmulatorPrefix,
                                variant,
                                archSuffix,
                                kExeExtension);
    D("Probing program: %s\n", path);
    if (p < pathEnd && path_exists(path)) {
        *is_64bit = false;
        return strdup(path);
    }

    // Not found, try in the current path then
    if (try_current_path) {
        char* result;

        if (search_for_64bit_emulator) {
            p = bufprint_emulatorName(path,
                                      pathEnd,
                                      NULL,
                                      kEmulator64Prefix,
                                      variant,
                                      archSuffix,
                                      kExeExtension);
            if (p < pathEnd) {
                D("Probing path for: %s\n", path);
                result = path_search_exec(path);
                if (result) {
                    *is_64bit = true;
                    return result;
                }
            }
        }

        p = bufprint_emulatorName(path,
                                    pathEnd,
                                    NULL,
                                    kEmulatorPrefix,
                                    variant,
                                    archSuffix,
                                    kExeExtension);
        if (p < pathEnd) {
            D("Probing path for: %s\n", path);
            result = path_search_exec(path);
            if (result) {
                *is_64bit = false;
                return result;
            }
        }
    }

    return NULL;
}

/*
 * emulator engine selection process is
 * emulator ->
 *   arm:
 *     32-bit: emulator(64)-arm
 *     64-bit: emulator(64)-arm64(NA) ->
               emulator(64)-ranchu-arm64 -> qemu/<host>/qemu-system-aarch64
 *   mips:
 *     32-bit: emulator(64)-mips
 *     64-bit: emulator(64)-mips64(NA) ->
               emulator(64)-ranchu-mips64 -> qemu/<host>/qemu-system-mips64
 *   x86:
 *     32-bit: (if '-ranchu')
 *               emulator(64)-ranchu-x86 -> qemu/<host>/qemu-system-x86
 *             else
 *               emulator(64)-x86
 *     64-bit: (if '-ranchu')
 *               emulator(64)-ranchu-x86_64 -> qemu/<host>/qemu-system-x86_64
 *             else
 *               emulator(64)-x86
 */
static char*
getTargetEmulatorPath(const char* progDir,
                      bool tryCurrentPath,
                      const char* avdArch,
                      const int force_32bit,
                      bool* is_64bit)
{
    char*  result;
    char* ranchu_result;
    bool search_for_64bit_emulator =
            !force_32bit && android_getHostBitness() == 64;
#ifdef _WIN32
    // Using emulator64-arm.exe results in a kernel panic while
    // x86/x86_64 emulator executables don't have this issue
    if (!strcmp(avdArch, "arm")) {
        search_for_64bit_emulator = false;
    }
#endif

    const char* emulatorSuffix;

    /* Try look for classic emulator first */
    emulatorSuffix = emulator_getBackendSuffix(avdArch);
    if (!emulatorSuffix) {
        APANIC("This emulator cannot emulate %s CPUs!\n", avdArch);
    }
    D("Looking for emulator-%s to emulate '%s' CPU\n", emulatorSuffix,
      avdArch);

    result = probeTargetEmulatorPath(progDir,
                                     NULL,
                                     emulatorSuffix,
                                     search_for_64bit_emulator,
                                     tryCurrentPath,
                                     is_64bit);
    if (result && !ranchu) {
        /* found and not ranchu */
        D("return result: %s\n", result);
        return result;
    } else {
        /* no classic emulator or prefer ranchu */
        D("Looking for ranchu emulator backend for %s CPU\n", avdArch);
        ranchu_result = probeTargetEmulatorPath(progDir,
                                                "ranchu",
                                                avdArch,
#ifdef _WIN32
                                                true, // 32 bit ranchu does not work on windows
#else
                                                search_for_64bit_emulator,
#endif
                                                tryCurrentPath,
                                                is_64bit);
        if (ranchu_result) {
            D("return ranchu: %s\n", ranchu_result);
            return ranchu_result;
        } else {
            if (result) {
                /* ranchu not found, fallback to classic
                   should NOT happen in current scenario
                   just go ahead still and leave a message
                */
                fprintf(stderr, "ERROR: requested 'ranchu' not available\n"
                        "classic backend is used\n");
                return result;
            }
        }
    }

    /* Otherwise, the program is missing */
    APANIC("Missing emulator engine program for '%s' CPUS.\n", avdArch);
    return NULL;
}