# Copyright (c) 2020, Riverbank Computing Limited
# All rights reserved.
#
# This copy of PyQt-builder is licensed for use under the terms of the SIP
# License Agreement.  See the file LICENSE for more details.
#
# This copy of PyQt-builder may also used under the terms of the GNU General
# Public License v2 or v3 as published by the Free Software Foundation which
# can be found in the files LICENSE-GPL2 and LICENSE-GPL3 included in this
# package.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.


import glob
import os
import sys

from sipbuild import Bindings, BuildableExecutable, UserException, Option


class PyQtBindings(Bindings):
    """ A base class for all PyQt-based bindings. """

    def apply_nonuser_defaults(self, tool):
        """ Set default values for non-user options that haven't been set yet.
        """

        project = self.project

        if self.sip_file is None:
            # The (not very good) naming convention used by MetaSIP.
            self.sip_file = os.path.join(self.name, self.name + 'mod.sip')

        super().apply_nonuser_defaults(tool)

        self._update_builder_settings('CONFIG', self.qmake_CONFIG)
        self._update_builder_settings('QT', self.qmake_QT)

        # Add the sources of any support code.
        qpy_dir = os.path.join(project.root_dir, 'qpy', self.name)
        if os.path.isdir(qpy_dir):
            headers = self._matching_files(os.path.join(qpy_dir, '*.h'))
            c_sources = self._matching_files(os.path.join(qpy_dir, '*.c'))
            cpp_sources = self._matching_files(os.path.join(qpy_dir, '*.cpp'))

            sources = c_sources + cpp_sources

            self.headers.extend(headers)
            self.sources.extend(sources)

            if headers or sources:
                self.include_dirs.append(qpy_dir)

    def apply_user_defaults(self, tool):
        """ Set default values for user options that haven't been set yet. """

        # Although tags is not a user option, the default depends on one.
        if len(self.tags) == 0:
            project = self.project

            self.tags = ['{}_{}'.format(project.tag_prefix,
                    project.builder.qt_version_tag)]

        super().apply_user_defaults(tool)

    def get_options(self):
        """ Return the list of configurable options. """

        options = super().get_options()

        # The list of modifications to make to the CONFIG value in a .pro file.
        # An element may start with '-' to specify that the value should be
        # removed.
        options.append(Option('qmake_CONFIG', option_type=list))

        # The list of modifications to make to the QT value in a .pro file.  An
        # element may start with '-' to specify that the value should be
        # removed.
        options.append(Option('qmake_QT', option_type=list))

        # The list of header files to #include in any internal test program.
        options.append(Option('test_headers', option_type=list))

        # The statement to execute in any internal test program.
        options.append(Option('test_statement'))

        return options

    def handle_test_output(self, test_output):
        """ Handle the output of any external test program and return True if
        the bindings are buildable.
        """

        # This default implementation assumes that the output is a list of
        # disabled features.

        if test_output:
            self.project.progress(
                    "Disabled {} bindings features: {}.".format(self.name,
                            ', '.join(test_output)))

            self.disabled_features.extend(test_output)

        return True

    def is_buildable(self):
        """ Return True of the bindings are buildable. """

        project = self.project

        test = 'cfgtest_' + self.name
        test_source = test + '.cpp'

        test_source_path = os.path.join(project.tests_dir, test_source)
        if os.path.isfile(test_source_path):
            # There is an external test program that should be run.
            run_test = True
        elif self.test_statement:
            # There is an internal test program that doesn't need to be run.
            test_source_path = None
            run_test = False
        else:
            # There is no test program so defer to the super-class.
            return super().is_buildable()

        self.project.progress(
                "Checking to see if the {0} bindings can be built".format(
                        self.name))

        # Create a buildable for the test prgram.
        buildable = BuildableExecutable(project, test, self.name)
        buildable.builder_settings.extend(self.builder_settings)
        buildable.debug = self.debug
        buildable.define_macros.extend(self.define_macros)
        buildable.include_dirs.extend(self.include_dirs)
        buildable.libraries.extend(self.libraries)
        buildable.library_dirs.extend(self.library_dirs)

        if test_source_path is None:
            # Save the internal test to a file.
            includes = ['#include <{}>'.format(h) for h in self.test_headers]

            source_text = '''%s

int main(int, char **)
{
    %s;
}
''' % ('\n'.join(includes), self.test_statement)

            test_source_path = os.path.join(buildable.build_dir, test_source)

            tf = project.open_for_writing(test_source_path)
            tf.write(source_text)
            tf.close()

        buildable.sources.append(test_source_path)

        # Build the test program.
        test_exe = project.builder.build_executable(buildable, fatal=False)
        if test_exe is None:
            return False

        # If the test doesn't need to be run then we are done.
        if not run_test:
            return True

        # Run the test and capture the output as a list of lines.
        test_exe = os.path.join(buildable.build_dir, test_exe)

        # Create the output file, first making sure it doesn't exist.  Note
        # that we don't use a pipe because we may want a copy of the output for
        # debugging purposes.
        out_file = os.path.join(buildable.build_dir, test + '.out')

        try:
            os.remove(out_file)
        except OSError:
            pass

        # Make sure the Qt DLLs get picked up.
        original_path = None

        if sys.platform == 'win32':
            qt_bin_dir = os.path.dirname(project.builder.qmake)
            path = os.environ['PATH']
            path_parts = path.split(os.path.pathsep)

            if qt_bin_dir not in path_parts:
                original_path = path

                path_parts.insert(0, qt_bin_dir)
                os.environ['PATH'] = os.pathsep.join(path_parts)

        self.project.run_command([test_exe, out_file], fatal=False)

        if original_path is not None:
            os.environ['PATH'] = original_path

        if not os.path.isfile(out_file):
            raise UserException(
                    "'{0}' didn't create any output".format(test_exe))

        # Read the details.
        with open(out_file) as f:
            test_output = f.read().strip()

        test_output = test_output.split('\n') if test_output else []

        return self.handle_test_output(test_output)

    @staticmethod
    def _matching_files(pattern):
        """ Return a reproducable list of files that match a pattern. """

        return sorted(glob.glob(pattern))

    def _update_builder_settings(self, name, modifications):
        """ Update the builder settings with a list of modifications to a
        value.
        """

        add = []
        remove = []

        for mod in modifications:
            if mod.startswith('-'):
                remove.append(mod[1:])
            else:
                add.append(mod)

        if add:
            self.builder_settings.append(
                    '{} += {}'.format(name, ' '.join(add)))

        if remove:
            self.builder_settings.append(
                    '{} -= {}'.format(name, ' '.join(remove)))
