#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

#############################################################################

##

## Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).

## All rights reserved.

## Contact: Nokia Corporation (developer.feedback@nokia.com)

##

## This file is part of the UI Extensions for Mobile.

##

## GNU Lesser General Public License Usage

## This file may be used under the terms of the GNU Lesser General Public

## License version 2.1 as published by the Free Software Foundation and

## appearing in the file LICENSE.LGPL included in the packaging of this file.

## Please review the following information to ensure the GNU Lesser General

## Public License version 2.1 requirements will be met:

## http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

##

## In addition, as a special exception, Nokia gives you certain additional

## rights.  These rights are described in the Nokia Qt LGPL Exception

## version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

##

## If you have questions regarding the use of this file, please contact

## Nokia at developer.feedback@nokia.com.

##

#############################################################################

import re

import os

import sys

import shutil

import fnmatch

import tempfile

import optparse

if sys.version_info[0] == 2 and sys.version_info[1] < 4:

    # for scratchbox compatibility

    import popen2

else:

    import subprocess

# ============================================================================

# Globals

# ============================================================================

HB_MAKE_PARTS = [ "tutorials" ]

HB_NOMAKE_PARTS = [ "tests", "performance", "localization" ]

QMAKE = None

MAKE = None

BUILDENV = None

# ============================================================================

# Utils

# ============================================================================

def add_remove_part(part, add):

    global HB_MAKE_PARTS, HB_NOMAKE_PARTS

    if add:

        while part in HB_NOMAKE_PARTS:

            HB_NOMAKE_PARTS.remove(part)

        if not part in HB_MAKE_PARTS:

            HB_MAKE_PARTS.append(part)

    else:

        while part in HB_MAKE_PARTS:

            HB_MAKE_PARTS.remove(part)

        if not part in HB_NOMAKE_PARTS:

            HB_NOMAKE_PARTS.append(part)

def run_system(args, cwd=None):

    old_epocroot = None

    env = os.environ.copy()

    if "EPOCROOT" in env:

        epocroot = env.get("EPOCROOT")

        if not (epocroot.endswith("\\") or epocroot.endswith("/")):

            os.putenv("EPOCROOT", "%s/" % epocroot)

            old_epocroot = epocroot

    if type(args) is list:

        args = " ".join(args)

    result = os.system(args)

    if old_epocroot != None:

        os.putenv("EPOCROOT", old_epocroot)

    return result

def run_process(args, cwd=None):

    code = 0

    output = ""

    env = os.environ.copy()

    if "EPOCROOT" in env:

        epocroot = env.get("EPOCROOT")

        if not (epocroot.endswith("\\") or epocroot.endswith("/")):

            env["EPOCROOT"] = "%s/" % epocroot        

    if os.name == "nt":

        args = ["cmd.exe", "/C"] + args

    try:

        if cwd != None:

            oldcwd = os.getcwd()

            os.chdir(cwd)

        if sys.version_info[0] == 2 and sys.version_info[1] < 4:

            process = popen2.Popen4(args)

            code = process.wait()

            output = process.fromchild.read()

        else:

            process = subprocess.Popen(args, env=env, stderr=subprocess.PIPE, stdout=subprocess.PIPE)

            (stdout, stderr) = process.communicate()

            code = process.returncode

            output = stdout + stderr

        if cwd != None:

            os.chdir(oldcwd)

    except:

        code = -1

    return [code, output]

def read_file(filepath):

    content = ""

    try:

        file = open(filepath, "r")

        content = file.read()

        file.close()

    except IOError, e:

        print(e)

    return content

def write_file(filepath, content):

    try:

        path = os.path.split(filepath)[0]

        if not os.path.exists(path):

            os.makedirs(path)

        file = open(filepath, "w")

        file.write(content)

        file.close()

    except Exception, e:

        print(e)

        return False

    return True

def grep(path, pattern, include = [], exclude = []):

    result = {}

    expr = re.compile(pattern)

    for root, dirs, files in os.walk(path):

        for filename in files:

            accept = True

            for ipattern in include:

                if not fnmatch.fnmatch(filename, ipattern):

                    accept = False

            for epattern in exclude:

                if fnmatch.fnmatch(filename, epattern):

                    accept = False

            if accept:

                filepath = os.path.normpath(os.path.join(root, filename))

                content = read_file(filepath)

                for match in expr.finditer(content):

                    if match.group(1):

                        if filename not in result:

                            result[filename] = []

                        result[filename].append(match.group(1))

    return result

# ============================================================================

# OptionParser

# ============================================================================

class OptionParser(optparse.OptionParser):

    def __init__(self):

        optparse.OptionParser.__init__(self, formatter=optparse.TitledHelpFormatter())

        self.add_option("-v", "--verbose", action="store_true", dest="verbose",

                        help="Print verbose information during the configure.")

        self.set_defaults(verbose=False)

        if QMAKE.platform() != "symbian":

            group = optparse.OptionGroup(self, "Installation options")

            group.add_option("--prefix", dest="prefix", metavar="dir",

                             help="Install everything relative to <dir>. The default value is '%s'. "

                                  "NOTE: Use '--prefix .' to configure a local setup. A local "

                                  "setup will install nothing else than the qmake "

                                  "feature file." % BUILDENV.default_prefix())

            group.add_option("--bin-dir", dest="bindir", metavar="dir",

                             help="Install executables to <dir>. The default value is 'PREFIX/bin'.")

            group.add_option("--lib-dir", dest="libdir", metavar="dir",

                             help="Install libraries to <dir>. The default value is 'PREFIX/lib'.")

            group.add_option("--doc-dir", dest="docdir", metavar="dir",

                             help="Install documentation to <dir>. The default value is 'PREFIX/doc'.")

            group.add_option("--include-dir", dest="includedir", metavar="dir",

                             help="Install headers to <dir>. The default value is 'PREFIX/include'.")

            group.add_option("--plugin-dir", dest="plugindir", metavar="dir",

                             help="Install plugins to <dir>. The default value is 'PREFIX/plugins'.")

            group.add_option("--features-dir", dest="featuresdir", metavar="dir",

                             help="Install qmake feature files to <dir>. The default value is 'QTDIR/mkspecs/features'.")

            group.add_option("--resources-dir", dest="resourcesdir", metavar="dir",

                             help="Install resources to <dir>. The default value is 'PREFIX/resources'.")

            self.add_option_group(group)

        self.set_defaults(prefix=None)

        self.set_defaults(bindir=None)

        self.set_defaults(libdir=None)

        self.set_defaults(docdir=None)

        self.set_defaults(includedir=None)

        self.set_defaults(pluginsdir=None)

        self.set_defaults(featuresdir=None)

        self.set_defaults(resourcesdir=None)

        group = optparse.OptionGroup(self, "Configure options")

        group.add_option("--platform", dest="platform", metavar="platform",

                         help="Specify the platform (symbian/win32/unix). "

                              "The one detected by qmake is used by default "

                              "if not specified.")

        group.add_option("--make-bin", dest="makebin", metavar="path",

                         help="Specify the make tool (make, nmake, mingw32-make, gmake...). "

                              "The one detected in PATH is used by default if not specified.")

        if QMAKE.platform() == "win32" and MAKE.bin() == "nmake":

            group.add_option("--msvc", action="store_true", dest="msvc",

                             help="Generate a MSVC solution.")

        group.add_option("--release", action="store_const", dest="config", const="release",

                         help="Build in release mode.")

        group.add_option("--debug", action="store_const", dest="config", const="debug",

                         help="Build in debug mode.")

        group.add_option("--debug_and_release", action="store_const", dest="config", const="debug_and_release",

                         help="Build in both debug and release modes.")

        group.add_option("--debug-output", action="store_false", dest="debug_output",

                         help="Do not suppress debug and warning output (suppressed by default in release mode).")

        group.add_option("--no-debug-output", action="store_true", dest="no_debug_output",

                         help="Suppress debug and warning output (not supporessed by default in debug mode).")

        if QMAKE.platform() != "symbian":

            group.add_option("--silent", action="store_true", dest="silent",

                             help="Suppress verbose compiler output.")

            group.add_option("--fast", action="store_true", dest="fast",

                             help="Run qmake in non-recursive mode. Running qmake "

                                  "in recursive mode (default) is more reliable but "

                                  "takes relatively long due to deep project hierarchy. "

                                  "The build tree should be clean ie. no existing "

                                  "makefiles in subdirs, because those won't be "

                                  "regenerated if this option is enabled.")

        group.add_option("--defines", dest="defines", metavar="defines",

                         help="Define compiler macros for selecting features "

                              "and debugging purposes eg. --defines HB_FOO_DEBUG,HB_BAR_ENABLED")

        if QMAKE.platform() == "unix":

            group.add_option("--rpath", action="store_true", dest="rpath",

                             help="Link Hb libraries and executables using the library install "

                                  "path as a runtime library path.")

            group.add_option("--no-rpath", action="store_false", dest="rpath",

                             help="Do not use the library install path as a runtime library path.")

        self.add_option_group(group)

        self.set_defaults(platform=None)

        self.set_defaults(makebin=None)

        self.set_defaults(msvc=None)

        self.set_defaults(config=None)

        self.set_defaults(silent=False)

        self.set_defaults(fast=False)

        self.set_defaults(defines=None)

        self.set_defaults(rpath=None)

        group = optparse.OptionGroup(self, "Host options")

        group.add_option("--host-qmake-bin", dest="hostqmakebin", metavar="path",

                         help="Specify the host qmake tool.")

        group.add_option("--host-make-bin", dest="hostmakebin", metavar="path",

                         help="Specify the host make tool (make, nmake, mingw32-make, gmake...).")

        self.add_option_group(group)

        self.set_defaults(hostqmakebin=None)

        self.set_defaults(hostmakebin=None)

        group = optparse.OptionGroup(self, "qmake options")

        group.add_option("--qmake-bin", dest="qmakebin", metavar="path",

                         help="Specify the path to the qmake. The one "

                              "in PATH is used by default if not specified.")

        group.add_option("--qmake-spec", dest="qmakespec", metavar="spec",

                         help="The operating system and compiler you are building on.")

        group.add_option("--qmake-options", dest="qmakeopt", metavar="options",

                         help="Additional qmake options "

                              "eg. --qmake-options \"CONFIG+=foo DEFINES+=BAR\".")

        self.add_option_group(group)

        self.set_defaults(qmakeopt=None)

        group = optparse.OptionGroup(self, "Feature options")

        group.add_option("--make", action="append", dest="make", metavar="part",

                         help="Do build <part>. Valid parts: tests localization performance")

        group.add_option("--nomake", action="append", dest="nomake", metavar="part",

                         help="Do not build <part>. Valid parts: <collection> tutorials tests fute unit localization performance")

        group.add_option("--no-effects", action="store_false", dest="effects",

                         help="Do not build effects.")

        group.add_option("--no-gestures", action="store_false", dest="gestures",

                         help="Do not build gestures.")

        group.add_option("--no-text-measurement", action="store_false", dest="textMeasurement",

                         help="Do not build text measurement support (needed for localization).")

        self.add_option_group(group)

        self.set_defaults(make=None)

        self.set_defaults(nomake=None)

        self.set_defaults(effects=True)

        self.set_defaults(gestures=True)

        self.set_defaults(textMeasurement=True)

        group = optparse.OptionGroup(self, "Qt options")

        group.add_option("--qt-mobility", action="store_true", dest="qtmobility",

                         help="Assumes that Qt Mobility is available without performing a compilation test.")

        group.add_option("--no-qt-mobility", action="store_false", dest="qtmobility",

                         help="Assumes that Qt Mobility is not available without performing a compilation test.")

        group.add_option("--meegotouch", action="store_true", dest="meegotouch",

                         help="Assumes that MeeGoTouch UI is available without performing a compilation test.")

        group.add_option("--no-meegotouch", action="store_false", dest="meegotouch",

                         help="Assumes that MeeGoTouch UI is not available without performing a compilation test.")

        group.add_option("--qt-openvg", action="store_true", dest="qtopenvg",

                         help="Assumes that OpenVG is available without performing a compilation test.")

        group.add_option("--no-qt-openvg", action="store_false", dest="qtopenvg",

                         help="Assumes that OpenVG is not available without performing a compilation test.")

        self.add_option_group(group)

        self.set_defaults(qtmobility=None)

        self.set_defaults(qtopenvg=None)

        group = optparse.OptionGroup(self, "Developer options")

        group.add_option("--developer", action="store_true", dest="developer",

                         help="Enables the developer mode. The developer mode implies "

                         "a local setup, enables tests and exports extra symbols for "

                         "testing purposes. NOTE: this is equal to: --prefix . --make tests "

                         "--developer-export")

        group.add_option("--developer-export", action="store_true", dest="developerexport",

                         help="Enables developer exports ie. extra symbols for testing purposes.")

        if QMAKE.platform() != "symbian":

            group.add_option("--coverage", action="store_true", dest="coverage",

                             help="Builds with test coverage measurement support. "

                                  "This implies the developer mode.")

        self.add_option_group(group)

        self.set_defaults(developer=False)

        self.set_defaults(developerexport=None)

        self.set_defaults(coverage=False)

# ============================================================================

# Make

# ============================================================================

class Make:

    def __init__(self):

        self._bin = None

    def init(self, cmdline):

        match = re.search("--make-bin[=\s](\S+)", cmdline)

        if match:

            self._bin = match.group(1)

        else:

            self._bin = self._detect_make()

    def command(self, target=None):

        _args = [self._bin]

        if target:

            _args += [target]

        return _args

    def bin(self):

        return self._bin

    def _detect_make(self):

        if QMAKE.platform() == "win32" and self._test_make("nmake", "/?"):

            return "nmake"

        if self._test_make("make", "-v"):

            return "make"

        if self._test_make("gmake", "-v"):

            return "gmake"

        if QMAKE.platform() == "win32" and self._test_make("mingw32-make", "-v"):

            return "mingw32-make"

        return "make"

    def _test_make(self, command, param):

        try:

            return run_process([command, param])[0] == 0

        except:

            return False

# ============================================================================

# QMake

# ============================================================================

class QMake:

    def __init__(self):

        self._bin = "qmake"

        self._platform = None

        self._error = None

        self._spec = None

        self._features = None

        self._qtdir = None

        self._qtversion = None

        self._args = []

    def init(self, cmdline):

        match = re.search("--qmake-bin[=\s](\S+)", cmdline)

        if match:

            self._bin = match.group(1)

        match = re.search("--platform[=\s](\S+)", cmdline)

        if match:

            self._platform = match.group(1)

        match = re.search("--qmake-spec[=\s](\S+)", cmdline)

        if match:

            self._spec = match.group(1)

        return self._run_qmake()

    def command(self, profile=None):

        _args = [self._bin]

        if self._spec:

            _args += ["-spec", self._spec]

        if len(self._args):

            _args += self._args

        if profile:

            _args += [profile]

        return _args

    def add_args(self, args):

        self._args += args

    def platform(self):

        return self._platform

    def bin(self):

        return self._bin

    def error(self):

        return self._error

    def spec(self):

        return self._spec

    def features(self):

        return self._features

    def qtdir(self):

        return self._qtdir

    def qtversion(self):

    def _run_qmake(self):

        # write .pro

        content = """

                  symbian:message(platform:symbian)

                  symbian:message(platform:symbian)

                  else:macx:message(platform:macx)

                  else:unix:message(platform:unix)

                  else:win32:message(platform:win32)

                  message(features:$$[QMAKE_MKSPECS]/features)

                  message(qtversion:$$[QT_VERSION])

                  message(qtdir:$$[QT_INSTALL_LIBS])

                  """

        if not write_file("tmp/qmake.pro", content):

            self._error = "Unable to write 'tmp/qmake.pro'. Make sure to configure in a writable directory."

            return False

        # run qmake

        args = [self._bin, "-nocache", "qmake.pro"]

        if self._spec:

            args += ["-spec", self._spec]

        (code, output) = run_process(args, "tmp")

        # cleanup & check return

        shutil.rmtree("tmp", ignore_errors=True)

        if code != 0:

            self._error = "Unable to execute %s" % self._bin

            if self._bin == "qmake":

                self._error += ". Add qmake to PATH or pass --qmake-bin <path/to/qmake>."

            return False

        # parse output

        try:

            if not self._platform:

                self._platform = re.search("Project MESSAGE: platform:(\S+)", output).group(1)

            self._features = re.search("Project MESSAGE: features:(\S+)", output).group(1)

            self._qtdir = re.search("Project MESSAGE: qtdir:(\S+)", output).group(1)

        except:

            self._error = "Unable to parse qmake output (%s)" % output.strip()

            if output.find("QMAKESPEC") != -1:

                self._error += ". Set QMAKESPEC environment variable or pass --qmake-spec <spec>."

            return False

        return True

# ============================================================================

# BuildEnvironment

# ============================================================================

class BuildEnvironment:

    def __init__(self):

        self._blddir = os.path.abspath(os.getcwd())

        self._srcdir = os.path.abspath(sys.path[0])

        self._prefix = None

        self._bindir = None

        self._libdir = None

        self._docdir = None

        self._includedir = None

        self._pluginsdir = None

        self._featuresdir = None

        self._resourcesdir = None

    def init(self, options):

        # prefix

        if options.prefix:

            # explicit

            self._prefix = options.prefix

        elif options.developer:

            # developer mode implies a "local" build

            self._prefix = self._blddir

        else:

            # fall back to default

            self._prefix = self.default_prefix()

        if QMAKE.platform() != "symbian":

            self._prefix = os.path.abspath(self._prefix)

        self._bindir = self._dir_option(options.bindir, self._prefix + "/bin")

        self._libdir = self._dir_option(options.libdir, self._prefix + "/lib")