# Copyright (c) 2011 Google Inc. All rights reserved.
# Copyright (c) 2015-2017 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# 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
# OWNER 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 os
import logging
import re
import sys
import platform

from webkitcorepy import Version

from webkitpy.common.memoized import memoized
from webkitpy.common.version_name_map import PUBLIC_TABLE, INTERNAL_TABLE, VersionNameMap
from webkitpy.common.system.executive import Executive, ScriptError
from webkitpy.port.config import apple_additions


_log = logging.getLogger(__name__)


class PlatformInfo(object):
    MAX = 2147483647

    """This class provides a consistent (and mockable) interpretation of
    system-specific values (like sys.platform and platform.mac_ver())
    to be used by the rest of the webkitpy code base.

    Public (static) properties:
    -- os_name
    -- os_version

    Note that 'future' is returned for os_version if the operating system is
    newer than one known to the code.
    """

    def __init__(self, sys_module=None, platform_module=None, executive=None):
        sys_module = sys_module or sys
        self._executive = executive or Executive()
        self._platform_module = platform_module
        self.os_name = self._determine_os_name(sys_module.platform)
        self.os_version = None

        self._is_cygwin = sys_module.platform == 'cygwin'

        if self.os_name.startswith('mac'):
            # Work around for <rdar://problem/70069051>
            if apple_additions() and getattr(apple_additions(), 'os_version', None):
                self.os_version = apple_additions().os_version(self._executive)
            else:
                self.os_version = Version.from_string(self._executive.run_command(['sw_vers', '-productVersion']).rstrip())
        elif self.os_name.startswith('win'):
            self.os_version = self._win_version()
        else:
            # Most other platforms (namely iOS) return conforming version strings.
            version = re.search(r'\d+.\d+(.\d+)?', (platform_module or platform).release())
            if version:
                self.os_version = Version.from_string(version.group(0))
            else:
                _log.debug('No OS version number found')

    def is_mac(self):
        return self.os_name == 'mac'

    def is_ios(self):
        return self.os_name == 'ios'

    def is_watchos(self):
        return self.os_name == 'watchos'

    def is_win(self):
        return self.os_name == 'win'

    def is_native_win(self):
        return self.is_win() and not self.is_cygwin()

    def is_cygwin(self):
        return self._is_cygwin

    def is_linux(self):
        return self.os_name == 'linux'

    def is_freebsd(self):
        return self.os_name == 'freebsd'

    def is_openbsd(self):
        return self.os_name == 'openbsd'

    def is_netbsd(self):
        return self.os_name == 'netbsd'

    @memoized
    def architecture(self):
        try:
            # Windows doesn't have built in uname, nor guarantee of
            # os.uname()
            if os.name == 'nt':
                return platform.uname()[4]

            # os.uname() won't work on embedded devices, we may support multiple architectures for a single embedded platform
            output = self._executive.run_command(['uname', '-m']).rstrip()
            if output:
                if self.is_mac() and output != 'x86_64':
                    output = 'arm64'
                return output
        except ScriptError:
            pass
        return os.uname()[4]

    def display_name(self):
        # platform.platform() returns Darwin information for Mac, which is just confusing.
        if self.is_mac():
            return "Mac OS X %s" % (self._platform_module or platform).mac_ver()[0]

        # Returns strings like:
        # Linux-2.6.18-194.3.1.el5-i686-with-redhat-5.5-Final
        # Windows-2008ServerR2-6.1.7600
        return (self._platform_module or platform).platform()

    def os_version_name(self, table=None):
        if not self.os_version:
            return None
        if table:
            return VersionNameMap.map(self).to_name(self.os_version, table=table)
        version_name = VersionNameMap.map(self).to_name(self.os_version, table=PUBLIC_TABLE)
        if not version_name:
            version_name = VersionNameMap.map(self).to_name(self.os_version, table=INTERNAL_TABLE)
        return version_name

    def total_bytes_memory(self):
        if self.is_mac():
            return int(self._executive.run_command(["sysctl", "-n", "hw.memsize"]))
        return None

    def terminal_width(self):
        """Returns MAX if the width cannot be determined."""
        try:
            if self.is_win():
                # From http://code.activestate.com/recipes/440694-determine-size-of-console-window-on-windows/
                from ctypes import windll, create_string_buffer
                handle = windll.kernel32.GetStdHandle(-12)  # -12 == stderr
                console_screen_buffer_info = create_string_buffer(22)  # 22 == sizeof(console_screen_buffer_info)
                if windll.kernel32.GetConsoleScreenBufferInfo(handle, console_screen_buffer_info):
                    import struct
                    _, _, _, _, _, left, _, right, _, _, _ = struct.unpack("hhhhHhhhhhh", console_screen_buffer_info.raw)
                    # Note that we return 1 less than the width since writing into the rightmost column
                    # automatically performs a line feed.
                    return right - left
                return self.MAX
            else:
                import fcntl
                import struct
                import termios
                packed = fcntl.ioctl(sys.stderr.fileno(), termios.TIOCGWINSZ, '\0' * 8)
                _, columns, _, _ = struct.unpack('HHHH', packed)
                return columns
        except:
            return self.MAX

    def build_version(self):
        if self.is_mac():
            return self._executive.run_command(['/usr/bin/sw_vers', '-buildVersion'], return_stderr=False, ignore_errors=True).rstrip()
        return None

    @memoized
    def xcode_sdk_version(self, sdk_name):
        if self.is_mac():
            # Assumes that xcrun does not write to standard output on failure (e.g. SDK does not exist).
            xcrun_output = self._executive.run_command(['xcrun', '--sdk', sdk_name, '--show-sdk-version'], return_stderr=False, ignore_errors=True).rstrip()
            if xcrun_output:
                return Version.from_string(xcrun_output)
        return None

    def xcode_simctl_list(self):
        if not self.is_mac():
            return ()
        output = self._executive.run_command(['xcrun', 'simctl', 'list'], return_stderr=False)
        return (line for line in output.splitlines())

    @memoized
    def xcode_version(self):
        if not self.xcode_sdk_version('macosx'):
            raise NotImplementedError
        return Version.from_string(self._executive.run_command(['xcodebuild', '-version']).split()[1])

    @memoized
    def available_sdks(self):
        if not self.xcode_sdk_version('macosx'):
            return []

        XCODE_SDK_REGEX = re.compile(r'\-sdk (?P<sdk>\D+)\d+\.\d+(?P<specifier>\D*)')
        output = self._executive.run_command(['xcodebuild', '-showsdks'], return_stderr=False)

        sdks = list()
        for line in output.splitlines():
            match = XCODE_SDK_REGEX.search(line)
            if match:
                sdks.append(match.group('sdk') + match.group('specifier'))
        return sdks

    def _determine_os_name(self, sys_platform):
        if sys_platform == 'darwin':
            return 'mac'
        if sys_platform == 'ios' or sys_platform == 'watchos':
            return 'ios'
        if sys_platform.startswith('linux'):
            return 'linux'
        if sys_platform.startswith('win') or sys_platform == 'cygwin':
            return 'win'
        if sys_platform.startswith('freebsd'):
            return 'freebsd'
        if sys_platform.startswith('netbsd'):
            return 'netbsd'
        if sys_platform.startswith('openbsd'):
            return 'openbsd'
        if sys_platform.startswith('haiku'):
            return 'haiku'
        raise AssertionError('unrecognized platform string "%s"' % sys_platform)

    def _win_version(self):
        version = self._win_version_str()
        match_object = re.search(r'(?P<major>\d+)\.(?P<minor>\d+)\.(?P<build>\d+)', version)
        assert match_object, 'cmd returned an unexpected version string: ' + version
        return Version.from_iterable(match_object.groups())

    def _win_version_str(self):
        version = (self._platform_module or platform).win32_ver()[1]
        if version:
            return version
        # Note that this should only ever be called on windows, so this should always work.
        return self._executive.run_command(['cmd', '/c', 'ver'], decode_output=True)