#!/usr/bin/env python

#############################################################################
##
## Copyright (C) 2015 The Qt Company Ltd.
## Contact: https://www.qt.io/licensing/
##
## This file is part of the QtWebEngine module of the Qt Toolkit.
##
## $QT_BEGIN_LICENSE:GPL-EXCEPT$
## Commercial License Usage
## Licensees holding valid commercial Qt licenses may use this file in
## accordance with the commercial license agreement provided with the
## Software or, alternatively, in accordance with the terms contained in
## a written agreement between you and The Qt Company. For licensing terms
## and conditions see https://www.qt.io/terms-conditions. For further
## information use the contact form at https://www.qt.io/contact-us.
##
## GNU General Public License Usage
## Alternatively, this file may be used under the terms of the GNU
## General Public License version 3 as published by the Free Software
## Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
## included in the packaging of this file. Please review the following
## information to ensure the GNU General Public License requirements will
## be met: https://www.gnu.org/licenses/gpl-3.0.html.
##
## $QT_END_LICENSE$
##
#############################################################################

import argparse
import os
import re
import subprocess
import shutil
import sys


class Api:
    QUICK = "webengine"
    WIDGET = "webenginewidgets"


class Mode:
    RELEASE = "release"
    DEBUG = "debug"


def is_windows():
    return os.name == "nt"


class ArgManager(object):
    def __init__(self):
        try:
            self.__args = self.__parse()
        except:
            raise

        self.build_dir = self.__args.build_dir
        self.src_dir = self.__args.src_dir
        self.example_filter = re.compile("%s-%s-%s" % (self.__api_filter(), self.__name_filter(), self.__mode_filter()))
        self.list_examples = self.__args.list_examples
        self.force = self.__args.force
        self.verbose = self.__args.verbose
        self.out_dir = self.__args.out_dir

    def __parse(self):
        ap = argparse.ArgumentParser(description="Deploy QtWebEngine example binaries on Windows.")
        ap.add_argument("--release", dest="release", action="store_true", default=False,
                        help="Deploy release binaries only")
        ap.add_argument("--debug", dest="debug", action="store_true", default=False,
                        help="Deploy debug binaries only")
        ap.add_argument("--quick", dest="quick", action="store_true", default=False,
                        help="Deploy quick examples only")
        ap.add_argument("--widget", dest="widget", action="store_true", default=False,
                        help="Deploy widget examples only")
        ap.add_argument("-e", "--examples", dest="examples", nargs="+", action="store", default=".*",
                        help="Select example to deploy")
        ap.add_argument("-l", "--list-examples", dest="list_examples", action="store_true", default=False,
                        help="List available examples")
        ap.add_argument("-f", "--force", dest="force", action="store_true", default=False,
                        help="Force to overwrite existing files")
        ap.add_argument("-v", "--verbose", dest="verbose", action="store_true", default=False,
                        help="Print windeployqt output")
        ap.add_argument("--src-dir", dest="src_dir", action="store", type=self.__validate_src_dir, default=None,
                        help="Specify path of Qt sources. It is used for finding QML files of the example"
                             "and scanning for QML imports")
        ap.add_argument("--build-dir", dest="build_dir", action="store", type=self.__validate_build_dir, default=None,
                        help="Specify path of the Qt binaries. It is used for finding qmake.exe, windeployqt.exe and"
                             "binaries of the examples. It is not necessary to set if qmake.exe is set in the path")
        ap.add_argument("-o", "--out-dir", dest="out_dir", action="store", default=os.getcwd(),
                        help="Specify path for the deployed examples. If it is not set"
                             "current working directory is used")
        return ap.parse_args()

    def __validate_src_dir(self, src_dir):
        if not os.path.exists(src_dir):
            raise OSError("The specified Qt source directory does not exist: %s" % src_dir)

        qtwebengine_dir = src_dir
        # Accept Qt top level source directory too
        if os.path.exists(os.path.join(src_dir, "qtwebengine")):
            qtwebengine_dir = os.path.join(src_dir, "qtwebengine")

        examples_dir = os.path.join(qtwebengine_dir, "examples")
        must_have_paths = [
            os.path.join(examples_dir, "examples.pro"),
            os.path.join(examples_dir, Api.QUICK),
            os.path.join(examples_dir, Api.WIDGET),
        ]

        # Check whether src_dir is the proper QtWebEngine source directory
        for p in must_have_paths:
            if not os.path.exists(p):
                raise OSError("The specified Qt source directory is invalid: %s" % src_dir)

        return src_dir

    def __validate_build_dir(self, build_dir):
        if not os.path.exists(build_dir):
            raise OSError("The specified Qt build directory does not exist: %s" % build_dir)

        # Accept QtWebEngine build directory too
        if os.path.basename(build_dir) == "qtwebengine":
            build_dir = os.path.abspath(os.path.join(build_dir, ".."))

        # Attempt to support custom build directories
        if os.path.exists(os.path.join(build_dir, "bin", "qmake.exe")):
            return build_dir

        # Check existence of qtbase/bin/qmake.exe
        qtbase_dir = os.path.join(build_dir, "qtbase")
        if not os.path.exists(os.path.join(qtbase_dir, "bin", "qmake.exe")):
            raise OSError("Program 'qmake.exe' cannot be found in the specified Qt build directory: %s" % build_dir)

        return qtbase_dir

    def __mode_filter(self):
        if self.__args.release and not self.__args.debug:
            return Mode.RELEASE
        if not self.__args.release and self.__args.debug:
            return Mode.DEBUG
        return ".*"

    def __api_filter(self):
        if self.__args.quick and not self.__args.widget:
            return Api.QUICK
        if not self.__args.quick and self.__args.widget:
            return Api.WIDGET
        return ".*"

    def __name_filter(self):
        alt_list = []

        examples = self.__args.examples
        if not isinstance(examples, list):
            examples = [examples]

        for e in examples:
            if "," in e:
                alt_list.extend(e.split(","))
            else:
                alt_list.append(e)

        return "|".join(alt_list)


class QtHelper(object):
    def __init__(self, build_path=None, src_path=None):
        self.__build_path = build_path if build_path is not None else ""
        self.__src_path = src_path if src_path is not None else ""
        self.__query = {}
        self.__angle = None

        self.__qmake = "qmake.exe"
        self.__windeployqt = "windeployqt.exe"
        if build_path:
            self.__qmake = os.path.join(self.__build_path, "bin", self.__qmake)
            self.__windeployqt = os.path.join(self.__build_path, "bin", self.__windeployqt)

        try:
            program = self.__qmake
            subprocess.check_output([program, "-v"])
            program = self.__windeployqt
            subprocess.check_output([program, "-h"])
        except OSError as e:
            raise OSError("Program '%s' cannot be executed\n%s" % (program, e))
        except:
            raise

        self.__query = self.get_query()
        self.__build_path = self.get_build_path()
        self.__src_path = self.get_src_path()
        self.__angle = self.has_angle()

    def get_query(self):
        if self.__query:
            return self.__query

        qmake_output = subprocess.check_output([self.__qmake, "-query"]).split("\r\n")
        query = {}
        for line in qmake_output:
            entry = line.split(":", 1)
            if len(entry) != 2:
                continue
            query[entry[0]] = entry[1]
        return query

    def get_build_path(self):
        return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX"], ".."))

    def get_src_path(self):
        if self.__src_path:
            return self.__src_path

        if "QT_INSTALL_PREFIX/src" in self.__query:
            return os.path.abspath(os.path.join(self.__query["QT_INSTALL_PREFIX/src"], ".."))

        return self.__build_path

    def get_windeployqt(self):
        return self.__windeployqt

    def has_angle(self):
        if self.__angle:
            return self.__angle

        qconfig_pri_path = os.path.abspath(os.path.join(self.__query["QT_HOST_PREFIX"], "mkspecs", "qconfig.pri"))
        print(qconfig_pri_path)
        if not os.path.exists(qconfig_pri_path):
            sys.stderr.write("Configuration file qconfig.pri cannot be found. Fallback to desktop GL mode.\n")
            return False

        qt_config = []

        qconfig_pri = open(qconfig_pri_path, "r")
        for line in qconfig_pri:
            if line.startswith("QT_CONFIG +="):
                qt_config = re.match("^QT_CONFIG \+= (.+)$", line).group(1).split(" ")
        qconfig_pri.close()

        return "angle" in qt_config

    def collect_examples(self):
        examples = []

        for api in [Api.QUICK, Api.WIDGET]:
            examples_root_dir_path = os.path.join(self.__build_path, "qtwebengine", "examples", api)
            if not os.path.exists(examples_root_dir_path):
                continue

            for example in os.listdir(examples_root_dir_path):
                example_dir_path = os.path.join(examples_root_dir_path, example)
                if not os.path.exists(example_dir_path):
                    continue

                example_src_path = os.path.join(self.__src_path, "qtwebengine", "examples", api, example)

                for mode in [Mode.RELEASE, Mode.DEBUG]:
                    example_exe_path = os.path.join(example_dir_path, mode, example + ".exe")
                    if not os.path.exists(example_exe_path):
                        continue
                    examples.append(Example(example, api, mode, self.__angle, example_exe_path, example_src_path))

        return examples


class Example(str):
    def __new__(cls, example, api, mode, angle, exe_path, src_path):
        obj = str.__new__(cls, "%s-%s-%s" % (api, example, mode))
        return obj

    def __init__(self, example, api, mode, angle, exe_path, src_path):
        super(Example, self).__init__("%s-%s-%s" % (api, example, mode))
        self.__name = example
        self.__api = api
        self.__mode = mode
        self.__angle = angle
        self.__exe_path = exe_path
        self.__src_path = src_path

    def get_deploy_params(self, mode, force):
        deploy_params = []
        deploy_params.append("--%s" % mode)
        deploy_params.append("--compiler-runtime")

        if self.__angle:
            deploy_params.append("--angle")

        if force:
            deploy_params.append("--force")

        if self.__api is Api.QUICK:
            deploy_params.append("--qmldir")
            deploy_params.append(self.__src_path)

        if self.__mode is Mode.DEBUG:
            deploy_params.append("--pdb")

        return deploy_params

    def name(self):
        return self.__name

    def deploy(self, qt, dest_path, force=False, verbose=False):
        src_path = os.path.dirname(self.__exe_path)
        for f in os.listdir(src_path):
            shutil.copy(os.path.join(src_path, f), dest_path)

        deploy_command = []
        deploy_command.append(qt.get_windeployqt())
        # Debug executables also need the release libraries
        deploy_command.extend(self.get_deploy_params(Mode.RELEASE, force))
        deploy_command.append(dest_path)

        if verbose:
            print("%s" % " ".join(deploy_command))

        out = None if verbose else open(os.devnull, "w")
        exit_code = subprocess.call(deploy_command, stdout=out)

        if self.__mode is Mode.DEBUG and not exit_code:
            param_release = "--%s" % Mode.RELEASE
            param_debug = "--%s" % Mode.DEBUG
            deploy_command = map(lambda item: param_debug if item == param_release else item, deploy_command)

            if verbose:
                print("%s" % " ".join(deploy_command))

            exit_code = subprocess.call(deploy_command, stdout=out)

        if out is not None:
            out.close()

        return exit_code


def main():
    try:
        args = ArgManager()

        if not is_windows():
            raise OSError("This script works on Windows only\n")

        qt = QtHelper(args.build_dir, args.src_dir)
    except Exception as e:
        sys.stderr.write(str(e))
        exit(1)

    example_list = filter((lambda e: args.example_filter.match(e)), qt.collect_examples())
    if not example_list:
        print("There is no example that fulfills the requirements")
        return

    for example in example_list:
        if args.list_examples:
            print(example.name())
            continue

        print("Deploying %s ..." % example.name())
        dest_path = os.path.abspath(os.path.join(args.out_dir, example.name()))
        if not os.path.exists(dest_path):
            os.makedirs(dest_path)
        elif os.listdir(dest_path) and not args.force:
            sys.stderr.write("Destination directory is not empty: %s\n" % dest_path)
            sys.stderr.write("Skip deploying %s\n" % example.name())
            continue

        exit_code = example.deploy(qt, dest_path, args.force, args.verbose)
        if exit_code:
            sys.stderr.write("Deploy of example '%s' has failed: %s\n" % (example.name(), exit_code))
            exit(exit_code)

        print("Example '%s' has been successfully deployed at %s" % (example.name(), dest_path))

    return

if __name__ == "__main__":
    main()