# Copyright (C) 2019 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:
# 1.  Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
# 2.  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.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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 json

from resultsdbpy.flask_support.util import FlaskJSONEncoder


class Configuration(object):
    """
    This class is designed to use a partial configuration to match more complete configurations. Generally, an instance
    of this class will match another instance if all members match or are None. This means that, for example, a
    Configuration object with a platform of 'Mac' and all other members set to None will match any Configuration object
    with a platform of 'Mac', regardless of the values of the Configuration's other members.
    """

    VERSION_OFFSET_CONSTANT = 1000

    REQUIRED_MEMBERS = ['platform', 'is_simulator', 'version', 'architecture']
    OPTIONAL_MEMBERS = ['version_name', 'model', 'style', 'flavor']
    FILTERING_MEMBERS = ['sdk']

    @classmethod
    def from_json(cls, data):
        data = data if isinstance(data, dict) else json.loads(data)
        return Configuration(**{key: data.get(key) for key in cls.REQUIRED_MEMBERS + cls.OPTIONAL_MEMBERS + ['sdk']})

    def __init__(self, platform=None, version=None, sdk=None, version_name=None, is_simulator=None, architecture=None, model=None, style=None, flavor=None):
        self.platform = None if platform is None else str(platform)
        self.version = None if version is None else self.version_to_integer(version)
        self.version_name = None if version_name is None else str(version_name)
        self.is_simulator = None if is_simulator is None else bool(is_simulator)
        self.architecture = None if architecture is None else str(architecture)
        self.model = None if model is None else str(model)
        self.style = None if style is None else str(style)
        self.flavor = None if flavor is None else str(flavor)

        # Configurations which are identical, except for their sdk, should be considered identical
        self.sdk = None
        if sdk and sdk != '?':
            self.sdk = str(sdk)

    @classmethod
    def version_to_integer(cls, version):
        if isinstance(version, int):
            return version
        elif isinstance(version, str):
            version_list = version.split('.')
        elif isinstance(version, list) or isinstance(version, tuple):
            version_list = version
        else:
            raise TypeError(f'{type(version)} cannot be converted to a version integer')
        if len(version_list) < 1 or len(version_list) > 3:
            raise ValueError(f'{version} cannot be converted to a version integer')

        index = 0
        result = 0
        while index < 3:
            result *= cls.VERSION_OFFSET_CONSTANT
            if index < len(version_list):
                result += int(version_list[index])
            index += 1

        return result

    @classmethod
    def integer_to_version(cls, version):
        assert isinstance(version, int)
        result = [0, 0, 0]
        for index in range(3):
            result[-(index + 1)] = version % cls.VERSION_OFFSET_CONSTANT
            version //= cls.VERSION_OFFSET_CONSTANT
        return f'{result[0]}.{result[1]}.{result[2]}'

    def is_complete(self):
        return not any([getattr(self, member) is None for member in self.REQUIRED_MEMBERS])

    def __eq__(self, other):
        if not isinstance(other, type(self)):
            return False
        for member in self.REQUIRED_MEMBERS + self.OPTIONAL_MEMBERS:
            if getattr(self, member) is None or getattr(other, member) is None:
                continue
            if getattr(self, member) == getattr(other, member):
                continue
            return False
        return True

    def __ne__(self, other):
        return not (self == other)

    def __lt__(self, other):
        if not isinstance(other, type(self)):
            raise TypeError(f'Cannot compare {type(other)} and {type(self)}')
        for member in ['version', 'platform', 'version_name', 'is_simulator', 'model', 'architecture', 'style', 'flavor']:
            mine = getattr(self, member)
            theirs = getattr(other, member)
            if mine is None and theirs is None:
                continue
            if mine is None and theirs is not None:
                return True
            if mine is not None and theirs is None:
                return False
            if mine < theirs:
                return True
            if mine > theirs:
                return False
        return False

    def __le__(self, other):
        return self.__lt__(other) or self.__eq__(other)

    def __gt__(self, other):
        if not isinstance(other, type(self)):
            raise TypeError(f'Cannot compare {type(other)} and {type(self)}')
        for member in ['version', 'platform', 'version_name', 'is_simulator', 'model', 'architecture', 'style', 'flavor']:
            mine = getattr(self, member)
            theirs = getattr(other, member)
            if mine is None and theirs is None:
                continue
            if mine is None and theirs is not None:
                return False
            if mine is not None and theirs is None:
                return True
            if mine < theirs:
                return False
            if mine > theirs:
                return True
        return False

    def __ge__(self, other):
        return self.__gt__(other) or self.__eq__(other)

    def __hash__(self):
        result = 0
        for member in self.REQUIRED_MEMBERS + self.OPTIONAL_MEMBERS + self.FILTERING_MEMBERS:
            if member == 'version_name' and getattr(self, 'version'):
                continue
            result ^= hash(getattr(self, member))
        return result

    def __repr__(self):
        result = ''
        if self.platform is not None:
            result += ' ' + self.platform
        if self.version is not None:
            result += ' ' + self.integer_to_version(self.version)
        elif self.version_name is not None:
            result += ' ' + self.version_name
        if self.sdk:
            result += f' ({self.sdk})'
        if self.is_simulator is not None and self.is_simulator:
            result += ' Simulator'
        if self.style is not None:
            result += ' ' + self.style
        if self.flavor is not None:
            result += ' ' + self.flavor
        if self.model is not None:
            result += ' running on ' + self.model
        if self.architecture is not None:
            result += ' using ' + self.architecture

        return result[1:]

    def to_json(self, pretty_print=False):
        return json.dumps(self, cls=self.Encoder, sort_keys=pretty_print, indent=4 if pretty_print else None)

    def to_query(self):
        query = ''
        for member in self.REQUIRED_MEMBERS + self.OPTIONAL_MEMBERS + self.FILTERING_MEMBERS:
            value = getattr(self, member)
            if value is None:
                continue

            if member == 'version':
                query += f'{member}={self.integer_to_version(value)}&'
            elif member == 'is_simulator':
                query += f"{member}={'True' if value else 'False'}&"
            else:
                query += f'{member}={value}&'
        if query:
            return query[:-1]
        return ''

    class Encoder(FlaskJSONEncoder):

        def default(self, obj):
            if isinstance(obj, Configuration):
                result = {}
                for key, value in obj.__dict__.items():
                    if value is None:
                        continue
                    result[key] = value
                return result
            return super(Configuration.Encoder, self).default(obj)