# Copyright (c) 2014 The Johns Hopkins University/Applied Physics Laboratory
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.

import six

from kmip.core import enums
from kmip.core.enums import HashingAlgorithm as HashingAlgorithmEnum
from kmip.core.enums import KeyFormatType as KeyFormatTypeEnum
from kmip.core.enums import Tags

from kmip.core import exceptions

from kmip.core.misc import KeyFormatType

from kmip.core import primitives
from kmip.core.primitives import Boolean
from kmip.core.primitives import ByteString
from kmip.core.primitives import Enumeration
from kmip.core.primitives import Integer
from kmip.core.primitives import Struct
from kmip.core.primitives import TextString

from kmip.core import utils
from kmip.core.utils import BytearrayStream

from enum import Enum


# 3.1
class UniqueIdentifier(TextString):

    def __init__(self, value=None, tag=Tags.UNIQUE_IDENTIFIER):
        super(UniqueIdentifier, self).__init__(value, tag)


class PrivateKeyUniqueIdentifier(UniqueIdentifier):

    def __init__(self, value=None):
        super(PrivateKeyUniqueIdentifier, self).__init__(
            value, Tags.PRIVATE_KEY_UNIQUE_IDENTIFIER)


class PublicKeyUniqueIdentifier(UniqueIdentifier):

    def __init__(self, value=None):
        super(PublicKeyUniqueIdentifier, self).__init__(
            value, Tags.PUBLIC_KEY_UNIQUE_IDENTIFIER)


# 3.2
class Name(Struct):

    class NameValue(TextString):

        def __init__(self, value=None):
            super(Name.NameValue, self).__init__(value, Tags.NAME_VALUE)

        def __eq__(self, other):
            if isinstance(other, Name.NameValue):
                if self.value == other.value:
                    return True
                else:
                    return False
            else:
                return NotImplemented

        def __repr__(self):
            return "{0}(value={1})".format(
                    type(self).__name__, repr(self.value))

        def __str__(self):
            return "{0}".format(self.value)

    class NameType(Enumeration):

        def __init__(self, value=None):
            super(Name.NameType, self).__init__(
                enums.NameType, value, Tags.NAME_TYPE)

        def __eq__(self, other):
            if isinstance(other, Name.NameType):
                if self.value == other.value:
                    return True
                else:
                    return False
            else:
                return NotImplemented

        def __repr__(self):
            return "{0}(value={1})".format(
                    type(self).__name__, repr(self.value))

        def __str__(self):
            return "{0}".format(self.value)

    def __init__(self, name_value=None, name_type=None):
        super(Name, self).__init__(tag=Tags.NAME)
        self.name_value = name_value
        self.name_type = name_type
        self.validate()

    def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        super(Name, self).read(istream, kmip_version=kmip_version)
        tstream = BytearrayStream(istream.read(self.length))

        # Read the value and type of the name
        self.name_value = Name.NameValue()
        self.name_type = Name.NameType()
        self.name_value.read(tstream, kmip_version=kmip_version)
        self.name_type.read(tstream, kmip_version=kmip_version)

        self.is_oversized(tstream)

    def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        tstream = BytearrayStream()

        # Write the value and type of the name
        self.name_value.write(tstream, kmip_version=kmip_version)
        self.name_type.write(tstream, kmip_version=kmip_version)

        # Write the length and value of the template attribute
        self.length = tstream.length()
        super(Name, self).write(ostream, kmip_version=kmip_version)
        ostream.write(tstream.buffer)

    def validate(self):
        self.__validate()

    def __validate(self):
        name = Name.__name__
        msg = exceptions.ErrorStrings.BAD_EXP_RECV
        if self.name_value and \
                not isinstance(self.name_value, Name.NameValue) and \
                not isinstance(self.name_value, str):
            member = 'name_value'
            raise TypeError(msg.format('{0}.{1}'.format(name, member),
                                       'name_value', type(Name.NameValue),
                                       type(self.name_value)))
        if self.name_type and \
                not isinstance(self.name_type, Name.NameType) and \
                not isinstance(self.name_type, str):
            member = 'name_type'
            raise TypeError(msg.format('{0}.{1}'.format(name, member),
                                       'name_type', type(Name.NameType),
                                       type(self.name_type)))

    @classmethod
    def create(cls, name_value, name_type):
        '''
            Returns a Name object, populated with the given value and type
        '''
        if isinstance(name_value, Name.NameValue):
            value = name_value
        elif isinstance(name_value, str):
            value = cls.NameValue(name_value)
        else:
            name = 'Name'
            msg = exceptions.ErrorStrings.BAD_EXP_RECV
            member = 'name_value'
            raise TypeError(msg.format('{0}.{1}'.format(name, member),
                                       'name_value', type(Name.NameValue),
                                       type(name_value)))

        if isinstance(name_type, Name.NameType):
            n_type = name_type
        elif isinstance(name_type, Enum):
            n_type = cls.NameType(name_type)
        else:
            name = 'Name'
            msg = exceptions.ErrorStrings.BAD_EXP_RECV
            member = 'name_type'
            raise TypeError(msg.format('{0}.{1}'.format(name, member),
                                       'name_type', type(Name.NameType),
                                       type(name_type)))

        return Name(name_value=value,
                    name_type=n_type)

    def __repr__(self):
        return "{0}(type={1},value={2})".format(
                type(self).__name__,
                repr(self.name_type),
                repr(self.name_value))

    def __str__(self):
        return "{0}".format(self.name_value.value)

    def __eq__(self, other):
        if isinstance(other, Name):
            if self.name_value == other.name_value and \
                        self.name_type == other.name_type:
                return True
            else:
                return False
        else:
            return NotImplemented

    def __ne__(self, other):
        return not self.__eq__(other)


# 3.3
class ObjectType(Enumeration):

    def __init__(self, value=None):
        super(ObjectType, self).__init__(
            enums.ObjectType, value, Tags.OBJECT_TYPE)


# 3.4
class CryptographicAlgorithm(Enumeration):

    def __init__(self, value=None):
        super(CryptographicAlgorithm, self).__init__(
            enums.CryptographicAlgorithm, value, Tags.CRYPTOGRAPHIC_ALGORITHM)


# 3.5
class CryptographicLength(Integer):

    def __init__(self, value=None):
        super(CryptographicLength, self).__init__(
            value, Tags.CRYPTOGRAPHIC_LENGTH)


# 3.6
class HashingAlgorithm(Enumeration):
    """
    An encodeable wrapper for the HashingAlgorithm enumeration.

    Used to specify the algorithm used to compute the Digest of a Managed
    Object. See Sections 3.17 and 9.1.3.2.16 of the KMIP v1.1 specification
    for more information.
    """

    def __init__(self, value=HashingAlgorithmEnum.SHA_256):
        """
        Construct a HashingAlgorithm object.

        Args:
            value (HashingAlgorithm): A HashingAlgorithm enumeration value,
                (e.g., HashingAlgorithm.MD5). Optional, defaults to
                HashingAlgorithm.SHA_256.
        """
        super(HashingAlgorithm, self).__init__(
            enums.HashingAlgorithm, value, Tags.HASHING_ALGORITHM)


class CryptographicParameters(Struct):
    """
    A set of values for cryptographic operations.

    A structure containing optional fields describing certain cryptographic
    parameters to be used when performing cryptographic operations with the
    associated KMIP object.
    """

    def __init__(self,
                 block_cipher_mode=None,
                 padding_method=None,
                 hashing_algorithm=None,
                 key_role_type=None,
                 digital_signature_algorithm=None,
                 cryptographic_algorithm=None,
                 random_iv=None,
                 iv_length=None,
                 tag_length=None,
                 fixed_field_length=None,
                 invocation_field_length=None,
                 counter_length=None,
                 initial_counter_value=None):
        super(CryptographicParameters, self).__init__(
            tag=Tags.CRYPTOGRAPHIC_PARAMETERS)

        self._block_cipher_mode = None
        self._padding_method = None
        self._hashing_algorithm = None
        self._key_role_type = None
        self._digital_signature_algorithm = None
        self._cryptographic_algorithm = None
        self._random_iv = None
        self._iv_length = None
        self._tag_length = None
        self._fixed_field_length = None
        self._invocation_field_length = None
        self._counter_length = None
        self._initial_counter_value = None

        self.block_cipher_mode = block_cipher_mode
        self.padding_method = padding_method
        self.hashing_algorithm = hashing_algorithm
        self.key_role_type = key_role_type
        self.digital_signature_algorithm = digital_signature_algorithm
        self.cryptographic_algorithm = cryptographic_algorithm
        self.random_iv = random_iv
        self.iv_length = iv_length
        self.tag_length = tag_length
        self.fixed_field_length = fixed_field_length
        self.invocation_field_length = invocation_field_length
        self.counter_length = counter_length
        self.initial_counter_value = initial_counter_value

    @property
    def block_cipher_mode(self):
        if self._block_cipher_mode:
            return self._block_cipher_mode.value
        else:
            return None

    @block_cipher_mode.setter
    def block_cipher_mode(self, value):
        if value is None:
            self._block_cipher_mode = None
        elif isinstance(value, enums.BlockCipherMode):
            self._block_cipher_mode = Enumeration(
                enums.BlockCipherMode,
                value=value,
                tag=Tags.BLOCK_CIPHER_MODE
            )
        else:
            raise TypeError(
                "block cipher mode must be a BlockCipherMode enumeration"
            )

    @property
    def padding_method(self):
        if self._padding_method:
            return self._padding_method.value
        else:
            return None

    @padding_method.setter
    def padding_method(self, value):
        if value is None:
            self._padding_method = None
        elif isinstance(value, enums.PaddingMethod):
            self._padding_method = Enumeration(
                enums.PaddingMethod,
                value=value,
                tag=Tags.PADDING_METHOD
            )
        else:
            raise TypeError(
                "padding method must be a PaddingMethod enumeration"
            )

    @property
    def hashing_algorithm(self):
        if self._hashing_algorithm:
            return self._hashing_algorithm.value
        else:
            return None

    @hashing_algorithm.setter
    def hashing_algorithm(self, value):
        if value is None:
            self._hashing_algorithm = None
        elif isinstance(value, enums.HashingAlgorithm):
            self._hashing_algorithm = Enumeration(
                enums.HashingAlgorithm,
                value=value,
                tag=Tags.HASHING_ALGORITHM
            )
        else:
            raise TypeError(
                "hashing algorithm must be a HashingAlgorithm enumeration"
            )

    @property
    def key_role_type(self):
        if self._key_role_type:
            return self._key_role_type.value
        else:
            return None

    @key_role_type.setter
    def key_role_type(self, value):
        if value is None:
            self._key_role_type = None
        elif isinstance(value, enums.KeyRoleType):
            self._key_role_type = Enumeration(
                enums.KeyRoleType,
                value=value,
                tag=Tags.KEY_ROLE_TYPE
            )
        else:
            raise TypeError(
                "key role type must be a KeyRoleType enumeration"
            )

    @property
    def digital_signature_algorithm(self):
        if self._digital_signature_algorithm:
            return self._digital_signature_algorithm.value
        else:
            return None

    @digital_signature_algorithm.setter
    def digital_signature_algorithm(self, value):
        if value is None:
            self._digital_signature_algorithm = None
        elif isinstance(value, enums.DigitalSignatureAlgorithm):
            self._digital_signature_algorithm = Enumeration(
                enums.DigitalSignatureAlgorithm,
                value=value,
                tag=Tags.DIGITAL_SIGNATURE_ALGORITHM
            )
        else:
            raise TypeError(
                "digital signature algorithm must be a "
                "DigitalSignatureAlgorithm enumeration"
            )

    @property
    def cryptographic_algorithm(self):
        if self._cryptographic_algorithm:
            return self._cryptographic_algorithm.value
        else:
            return None

    @cryptographic_algorithm.setter
    def cryptographic_algorithm(self, value):
        if value is None:
            self._cryptographic_algorithm = None
        elif isinstance(value, enums.CryptographicAlgorithm):
            self._cryptographic_algorithm = Enumeration(
                enums.CryptographicAlgorithm,
                value=value,
                tag=Tags.CRYPTOGRAPHIC_ALGORITHM
            )
        else:
            raise TypeError(
                "cryptographic algorithm must be a CryptographicAlgorithm "
                "enumeration"
            )

    @property
    def random_iv(self):
        if self._random_iv:
            return self._random_iv.value
        else:
            return None

    @random_iv.setter
    def random_iv(self, value):
        if value is None:
            self._random_iv = None
        elif isinstance(value, bool):
            self._random_iv = Boolean(
                value=value,
                tag=Tags.RANDOM_IV
            )
        else:
            raise TypeError("random iv must be a boolean")

    @property
    def iv_length(self):
        if self._iv_length:
            return self._iv_length.value
        else:
            return None

    @iv_length.setter
    def iv_length(self, value):
        if value is None:
            self._iv_length = None
        elif isinstance(value, six.integer_types):
            self._iv_length = Integer(
                value=value,
                tag=Tags.IV_LENGTH
            )
        else:
            raise TypeError("iv length must be an integer")

    @property
    def tag_length(self):
        if self._tag_length:
            return self._tag_length.value
        else:
            return None

    @tag_length.setter
    def tag_length(self, value):
        if value is None:
            self._tag_length = None
        elif isinstance(value, six.integer_types):
            self._tag_length = Integer(
                value=value,
                tag=Tags.TAG_LENGTH
            )
        else:
            raise TypeError("tag length must be an integer")

    @property
    def fixed_field_length(self):
        if self._fixed_field_length:
            return self._fixed_field_length.value
        else:
            return None

    @fixed_field_length.setter
    def fixed_field_length(self, value):
        if value is None:
            self._fixed_field_length = None
        elif isinstance(value, six.integer_types):
            self._fixed_field_length = Integer(
                value=value,
                tag=Tags.FIXED_FIELD_LENGTH
            )
        else:
            raise TypeError("fixed field length must be an integer")

    @property
    def invocation_field_length(self):
        if self._invocation_field_length:
            return self._invocation_field_length.value
        else:
            return None

    @invocation_field_length.setter
    def invocation_field_length(self, value):
        if value is None:
            self._invocation_field_length = None
        elif isinstance(value, six.integer_types):
            self._invocation_field_length = Integer(
                value=value,
                tag=Tags.INVOCATION_FIELD_LENGTH
            )
        else:
            raise TypeError("invocation field length must be an integer")

    @property
    def counter_length(self):
        if self._counter_length:
            return self._counter_length.value
        else:
            return None

    @counter_length.setter
    def counter_length(self, value):
        if value is None:
            self._counter_length = None
        elif isinstance(value, six.integer_types):
            self._counter_length = Integer(
                value=value,
                tag=Tags.COUNTER_LENGTH
            )
        else:
            raise TypeError("counter length must be an integer")

    @property
    def initial_counter_value(self):
        if self._initial_counter_value:
            return self._initial_counter_value.value
        else:
            return None

    @initial_counter_value.setter
    def initial_counter_value(self, value):
        if value is None:
            self._initial_counter_value = None
        elif isinstance(value, six.integer_types):
            self._initial_counter_value = Integer(
                value=value,
                tag=Tags.INITIAL_COUNTER_VALUE
            )
        else:
            raise TypeError("initial counter value must be an integer")

    def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        super(CryptographicParameters, self).read(
            istream,
            kmip_version=kmip_version
        )
        tstream = BytearrayStream(istream.read(self.length))

        if self.is_tag_next(Tags.BLOCK_CIPHER_MODE, tstream):
            self._block_cipher_mode = Enumeration(
                enums.BlockCipherMode,
                tag=Tags.BLOCK_CIPHER_MODE
            )
            self._block_cipher_mode.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.PADDING_METHOD, tstream):
            self._padding_method = Enumeration(
                enums.PaddingMethod,
                tag=Tags.PADDING_METHOD
            )
            self._padding_method.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.HASHING_ALGORITHM, tstream):
            self._hashing_algorithm = Enumeration(
                enums.HashingAlgorithm,
                tag=Tags.HASHING_ALGORITHM
            )
            self._hashing_algorithm.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.KEY_ROLE_TYPE, tstream):
            self._key_role_type = Enumeration(
                enums.KeyRoleType,
                tag=Tags.KEY_ROLE_TYPE
            )
            self._key_role_type.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.DIGITAL_SIGNATURE_ALGORITHM, tstream):
            self._digital_signature_algorithm = Enumeration(
                enums.DigitalSignatureAlgorithm,
                tag=Tags.DIGITAL_SIGNATURE_ALGORITHM
            )
            self._digital_signature_algorithm.read(
                tstream,
                kmip_version=kmip_version
            )

        if self.is_tag_next(Tags.CRYPTOGRAPHIC_ALGORITHM, tstream):
            self._cryptographic_algorithm = Enumeration(
                enums.CryptographicAlgorithm,
                tag=Tags.CRYPTOGRAPHIC_ALGORITHM
            )
            self._cryptographic_algorithm.read(
                tstream,
                kmip_version=kmip_version
            )

        if self.is_tag_next(Tags.RANDOM_IV, tstream):
            self._random_iv = Boolean(tag=Tags.RANDOM_IV)
            self._random_iv.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.IV_LENGTH, tstream):
            self._iv_length = Integer(tag=Tags.IV_LENGTH)
            self._iv_length.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.TAG_LENGTH, tstream):
            self._tag_length = Integer(tag=Tags.TAG_LENGTH)
            self._tag_length.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.FIXED_FIELD_LENGTH, tstream):
            self._fixed_field_length = Integer(tag=Tags.FIXED_FIELD_LENGTH)
            self._fixed_field_length.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.INVOCATION_FIELD_LENGTH, tstream):
            self._invocation_field_length = Integer(
                tag=Tags.INVOCATION_FIELD_LENGTH
            )
            self._invocation_field_length.read(
                tstream,
                kmip_version=kmip_version
            )

        if self.is_tag_next(Tags.COUNTER_LENGTH, tstream):
            self._counter_length = Integer(tag=Tags.COUNTER_LENGTH)
            self._counter_length.read(tstream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.INITIAL_COUNTER_VALUE, tstream):
            self._initial_counter_value = Integer(
                tag=Tags.INITIAL_COUNTER_VALUE
            )
            self._initial_counter_value.read(
                tstream,
                kmip_version=kmip_version
            )

        self.is_oversized(tstream)

    def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        tstream = BytearrayStream()

        if self._block_cipher_mode:
            self._block_cipher_mode.write(tstream, kmip_version=kmip_version)
        if self._padding_method:
            self._padding_method.write(tstream, kmip_version=kmip_version)
        if self._hashing_algorithm:
            self._hashing_algorithm.write(tstream, kmip_version=kmip_version)
        if self._key_role_type:
            self._key_role_type.write(tstream, kmip_version=kmip_version)
        if self._digital_signature_algorithm:
            self._digital_signature_algorithm.write(
                tstream,
                kmip_version=kmip_version
            )
        if self._cryptographic_algorithm:
            self._cryptographic_algorithm.write(
                tstream,
                kmip_version=kmip_version
            )
        if self._random_iv:
            self._random_iv.write(tstream, kmip_version=kmip_version)
        if self._iv_length:
            self._iv_length.write(tstream, kmip_version=kmip_version)
        if self._tag_length:
            self._tag_length.write(tstream, kmip_version=kmip_version)
        if self._fixed_field_length:
            self._fixed_field_length.write(tstream, kmip_version=kmip_version)
        if self._invocation_field_length:
            self._invocation_field_length.write(
                tstream,
                kmip_version=kmip_version
            )
        if self._counter_length:
            self._counter_length.write(tstream, kmip_version=kmip_version)
        if self._initial_counter_value:
            self._initial_counter_value.write(
                tstream,
                kmip_version=kmip_version
            )

        self.length = tstream.length()
        super(CryptographicParameters, self).write(
            ostream,
            kmip_version=kmip_version
        )
        ostream.write(tstream.buffer)

    def __eq__(self, other):
        if isinstance(other, CryptographicParameters):
            if self.block_cipher_mode != other.block_cipher_mode:
                return False
            elif self.padding_method != other.padding_method:
                return False
            elif self.hashing_algorithm != other.hashing_algorithm:
                return False
            elif self.key_role_type != other.key_role_type:
                return False
            elif self.digital_signature_algorithm \
                    != other.digital_signature_algorithm:
                return False
            elif self.cryptographic_algorithm != other.cryptographic_algorithm:
                return False
            elif self.random_iv != other.random_iv:
                return False
            elif self.iv_length != other.iv_length:
                return False
            elif self.tag_length != other.tag_length:
                return False
            elif self.fixed_field_length != other.fixed_field_length:
                return False
            elif self.invocation_field_length != other.invocation_field_length:
                return False
            elif self.counter_length != other.counter_length:
                return False
            elif self.initial_counter_value != other.initial_counter_value:
                return False
            else:
                return True

    def __ne__(self, other):
        if isinstance(other, CryptographicParameters):
            return not self == other
        else:
            return NotImplemented

    def __repr__(self):
        args = ", ".join([
            "block_cipher_mode={0}".format(self.block_cipher_mode),
            "padding_method={0}".format(self.padding_method),
            "hashing_algorithm={0}".format(self.hashing_algorithm),
            "key_role_type={0}".format(self.key_role_type),
            "digital_signature_algorithm={0}".format(
                self.digital_signature_algorithm
            ),
            "cryptographic_algorithm={0}".format(
                self.cryptographic_algorithm
            ),
            "random_iv={0}".format(self.random_iv),
            "iv_length={0}".format(self.iv_length),
            "tag_length={0}".format(self.tag_length),
            "fixed_field_length={0}".format(self.fixed_field_length),
            "invocation_field_length={0}".format(
                self.invocation_field_length
            ),
            "counter_length={0}".format(self.counter_length),
            "initial_counter_value={0}".format(self.initial_counter_value)
        ])
        return "CryptographicParameters({0})".format(args)

    def __str__(self):
        return str({
            'block_cipher_mode': self.block_cipher_mode,
            'padding_method': self.padding_method,
            'hashing_algorithm': self.hashing_algorithm,
            'key_role_type': self.key_role_type,
            'digital_signature_algorithm': self.digital_signature_algorithm,
            'cryptographic_algorithm': self.cryptographic_algorithm,
            'random_iv': self.random_iv,
            'iv_length': self.iv_length,
            'tag_length': self.tag_length,
            'fixed_field_length': self.fixed_field_length,
            'invocation_field_length': self.invocation_field_length,
            'counter_length': self.counter_length,
            'initial_counter_value': self.initial_counter_value
        })


class CertificateType(Enumeration):
    """
    An encodeable wrapper for the CertificateType enumeration.

    Used to specify the type of the encoded bytes of a Certificate Managed
    Object. See Sections 2.2.1 and 3.8 of the KMIP v1.1 specification for more
    information.
    """

    def __init__(self, value=enums.CertificateType.X_509):
        """
        Construct a CertificateType object.

        Args:
            value (CertificateType): A CertificateType enumeration
                value, (e.g., CertificateType.PGP). Optional, defaults to
                CertificateType.X_509.
        """
        super(CertificateType, self).__init__(
            enums.CertificateType, value, Tags.CERTIFICATE_TYPE)


class DigestValue(ByteString):
    """
    A byte string representing the hash value of a Digest.

    Used to hold the bytes of the digest hash value. Automatically generated
    by the KMIP server, the value is empty if the server does not have access
    to the value or encoding of the related Managed Object. See Section 3.17
    of the KMIP 1.1 specification for more information.

    Attributes:
        value: The bytes of the hash.
    """

    def __init__(self, value=b''):
        """
        Construct a DigestValue object.

        Args:
            value (bytes): The bytes of the hash. Optional, defaults to
                the empty byte string.
        """
        super(DigestValue, self).__init__(value, Tags.DIGEST_VALUE)


class Digest(Struct):
    """
    A structure storing a hash digest of a Managed Object.

    Digests may be calculated for keys, secret data objects, certificates, and
    opaque data objects and are generated when the object is created or
    registered with the KMIP server. See Section 3.17 of the KMIP 1.1
    specification for more information.

    Attributes:
        hashing_algorithm: The algorithm used to compute the hash digest.
        digest_value: The bytes representing the hash digest value.
        key_format_type: The type of the key the hash was generated for.
    """

    def __init__(self,
                 hashing_algorithm=None,
                 digest_value=None,
                 key_format_type=None):
        """
        Construct a Digest object.

        Args:
            hashing_algorithm (HashingAlgorithm): The hash algorithm used to
                compute the value of the digest. Optional, defaults to None.
            digest_value (DigestValue): The byte string representing the
                value of the hash digest. Optional, defaults to None.
            key_format_type (KeyFormatType): The format type of the key the
                hash was computed for, if the object in question is a key.
                Optional, defaults to None.
        """
        super(Digest, self).__init__(Tags.DIGEST)

        if hashing_algorithm is None:
            self.hashing_algorithm = HashingAlgorithm()
        else:
            self.hashing_algorithm = hashing_algorithm

        if digest_value is None:
            self.digest_value = DigestValue()
        else:
            self.digest_value = digest_value

        if key_format_type is None:
            self.key_format_type = KeyFormatType()
        else:
            self.key_format_type = key_format_type

        self.validate()

    def read(self, istream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Read the data encoding the Digest object and decode it into its
        constituent parts.

        Args:
            istream (Stream): A data stream containing encoded object data,
                supporting a read method; usually a BytearrayStream object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be decoded. Optional,
                defaults to KMIP 1.0.
        """
        super(Digest, self).read(istream, kmip_version=kmip_version)
        tstream = BytearrayStream(istream.read(self.length))

        self.hashing_algorithm.read(tstream, kmip_version=kmip_version)
        self.digest_value.read(tstream, kmip_version=kmip_version)
        self.key_format_type.read(tstream, kmip_version=kmip_version)

        self.is_oversized(tstream)
        self.validate()

    def write(self, ostream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the Digest object to a stream.

        Args:
            ostream (Stream): A data stream in which to encode object data,
                supporting a write method; usually a BytearrayStream object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be encoded. Optional,
                defaults to KMIP 1.0.
        """
        tstream = BytearrayStream()

        self.hashing_algorithm.write(tstream, kmip_version=kmip_version)
        self.digest_value.write(tstream, kmip_version=kmip_version)
        self.key_format_type.write(tstream, kmip_version=kmip_version)

        self.length = tstream.length()
        super(Digest, self).write(ostream, kmip_version=kmip_version)
        ostream.write(tstream.buffer)

    def validate(self):
        """
        Error check the attributes of the Digest object.
        """
        self.__validate()

    def __validate(self):
        # TODO (peter-hamilton) Add checks comparing the length of the digest
        # value against the standard length for the stated hashing algorithm.
        if not isinstance(self.hashing_algorithm, HashingAlgorithm):
            msg = "invalid hashing algorithm"
            msg += "; expected {0}, received {1}".format(
                HashingAlgorithm, self.hashing_algorithm)
            raise TypeError(msg)

        if not isinstance(self.digest_value, DigestValue):
            msg = "invalid digest value"
            msg += "; expected {0}, received {1}".format(
                DigestValue, self.digest_value)
            raise TypeError(msg)

        if not isinstance(self.key_format_type, KeyFormatType):
            msg = "invalid key format type"
            msg += "; expected {0}, received {1}".format(
                KeyFormatType, self.key_format_type)
            raise TypeError(msg)

    def __eq__(self, other):
        if isinstance(other, Digest):
            if self.hashing_algorithm != other.hashing_algorithm:
                return False
            elif self.digest_value != other.digest_value:
                return False
            elif self.key_format_type != other.key_format_type:
                return False
            else:
                return True
        else:
            return NotImplemented

    def __ne__(self, other):
        if isinstance(other, Digest):
            return not (self == other)
        else:
            return NotImplemented

    def __repr__(self):
        hashing_algorithm = "hashing_algorithm={0}".format(
            repr(self.hashing_algorithm))
        digest_value = "digest_value={0}".format(
            repr(self.digest_value))
        key_format_type = "key_format_type={0}".format(
            repr(self.key_format_type))

        return "Digest({0}, {1}, {2})".format(
            hashing_algorithm, digest_value, key_format_type)

    def __str__(self):
        return str(self.digest_value)

    @classmethod
    def create(cls,
               hashing_algorithm=HashingAlgorithmEnum.SHA_256,
               digest_value=b'',
               key_format_type=KeyFormatTypeEnum.RAW):
        """
        Construct a Digest object from provided digest values.

        Args:
            hashing_algorithm (HashingAlgorithm): An enumeration representing
                the hash algorithm used to compute the digest. Optional,
                defaults to HashingAlgorithm.SHA_256.
            digest_value (byte string): The bytes of the digest hash. Optional,
                defaults to the empty byte string.
            key_format_type (KeyFormatType): An enumeration representing the
                format of the key corresponding to the digest. Optional,
                defaults to KeyFormatType.RAW.

        Returns:
            Digest: The newly created Digest.

        Example:
            >>> x = Digest.create(HashingAlgorithm.MD5, b'\x00',
            ... KeyFormatType.RAW)
            >>> x.hashing_algorithm
            HashingAlgorithm(value=HashingAlgorithm.MD5)
            >>> x.digest_value
            DigestValue(value=bytearray(b'\x00'))
            >>> x.key_format_type
            KeyFormatType(value=KeyFormatType.RAW)
        """
        algorithm = HashingAlgorithm(hashing_algorithm)
        value = DigestValue(bytearray(digest_value))
        format_type = KeyFormatType(key_format_type)

        return Digest(hashing_algorithm=algorithm,
                      digest_value=value,
                      key_format_type=format_type)


# 3.18
class OperationPolicyName(TextString):

    def __init__(self, value=None):
        super(OperationPolicyName, self).__init__(
            value, Tags.OPERATION_POLICY_NAME)


# 3.19
class CryptographicUsageMask(Integer):

    ENUM_TYPE = enums.CryptographicUsageMask

    def __init__(self, value=None):
        super(CryptographicUsageMask, self).__init__(
            value, Tags.CRYPTOGRAPHIC_USAGE_MASK)


class State(Enumeration):

    def __init__(self, value=None):
        super(State, self).__init__(enums.State, value, Tags.STATE)


class ApplicationSpecificInformation(primitives.Struct):
    """
    A structure used to store data specific to the applications that use a
    Managed Object.

    An attribute of Managed Objects, it may be specified during the creation or
    modification of any server Managed Object.

    Attributes:
        application_namespace: The name of a namespace supported by the server.
        application_data: String data relevant to the specified namespace.

    See Section 3.36 of the KMIP v1.1 specification for more information.
    """

    def __init__(self, application_namespace=None, application_data=None):
        """
        Construct an ApplicationSpecificInformation object.

        Args:
            application_namespace (string): The name of a namespace supported
                by the server. Optional, defaults to None. Required for
                read/write.
            application_data (string): String data relevant to the specified
                namespace. Optional, defaults to None. Required for read/write.
        """
        super(ApplicationSpecificInformation, self).__init__(
            enums.Tags.APPLICATION_SPECIFIC_INFORMATION
        )

        self._application_namespace = None
        self._application_data = None

        self.application_namespace = application_namespace
        self.application_data = application_data

    @property
    def application_namespace(self):
        if self._application_namespace:
            return self._application_namespace.value
        return None

    @application_namespace.setter
    def application_namespace(self, value):
        if value is None:
            self._application_namespace = None
        elif isinstance(value, six.string_types):
            self._application_namespace = primitives.TextString(
                value=value,
                tag=enums.Tags.APPLICATION_NAMESPACE
            )
        else:
            raise TypeError("The application namespace must be a string.")

    @property
    def application_data(self):
        if self._application_data:
            return self._application_data.value
        return None

    @application_data.setter
    def application_data(self, value):
        if value is None:
            self._application_data = None
        elif isinstance(value, six.string_types):
            self._application_data = primitives.TextString(
                value=value,
                tag=enums.Tags.APPLICATION_DATA
            )
        else:
            raise TypeError("The application data must be a string.")

    def read(self, input_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Read the data encoding the ApplicationSpecificInformation attribute
        and decode it.

        Args:
            input_buffer (stream): A data stream containing encoded object
                data, supporting a read method; usually a BytearrayStream
                object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be decoded. Optional,
                defaults to KMIP 1.0.
        """
        super(ApplicationSpecificInformation, self).read(
            input_buffer,
            kmip_version=kmip_version
        )
        local_buffer = utils.BytearrayStream(input_buffer.read(self.length))

        if self.is_tag_next(enums.Tags.APPLICATION_NAMESPACE, local_buffer):
            self._application_namespace = primitives.TextString(
                tag=enums.Tags.APPLICATION_NAMESPACE
            )
            self._application_namespace.read(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidKmipEncoding(
                "The ApplicationSpecificInformation encoding is missing the "
                "ApplicationNamespace field."
            )
        if self.is_tag_next(enums.Tags.APPLICATION_DATA, local_buffer):
            self._application_data = primitives.TextString(
                tag=enums.Tags.APPLICATION_DATA
            )
            self._application_data.read(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidKmipEncoding(
                "The ApplicationSpecificInformation encoding is missing the "
                "ApplicationData field."
            )

        self.is_oversized(local_buffer)

    def write(self, output_buffer, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the ApplicationSpecificInformation object to a
        buffer.

        Args:
            output_buffer (stream): A data stream in which to encode object
                data, supporting a write method; usually a BytearrayStream
                object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be encoded. Optional,
                defaults to KMIP 1.0.
        """
        local_buffer = utils.BytearrayStream()

        if self._application_namespace:
            self._application_namespace.write(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidField(
                "The ApplicationSpecificInformation object is missing the "
                "ApplicationNamespace field."
            )
        if self._application_data:
            self._application_data.write(
                local_buffer,
                kmip_version=kmip_version
            )
        else:
            raise exceptions.InvalidField(
                "The ApplicationSpecificInformation object is missing the "
                "ApplicationData field."
            )

        self.length = local_buffer.length()
        super(ApplicationSpecificInformation, self).write(
            output_buffer,
            kmip_version=kmip_version
        )
        output_buffer.write(local_buffer.buffer)

    def __repr__(self):
        args = [
            "application_namespace={}".format(
                repr(self.application_namespace)
            ),
            "application_data={}".format(repr(self.application_data))
        ]
        return "ApplicationSpecificInformation({})".format(", ".join(args))

    def __str__(self):
        value = ", ".join(
            [
                '"application_namespace": "{}"'.format(
                    self.application_namespace
                ),
                '"application_data": "{}"'.format(self.application_data)
            ]
        )
        return "{" + value + "}"

    def __eq__(self, other):
        if isinstance(other, ApplicationSpecificInformation):
            if self.application_namespace != other.application_namespace:
                return False
            if self.application_data != other.application_data:
                return False
            return True
        else:
            return NotImplemented

    def __ne__(self, other):
        if isinstance(other, ApplicationSpecificInformation):
            return not self.__eq__(other)
        else:
            return NotImplemented


# 3.37
class ContactInformation(TextString):

    def __init__(self, value=None):
        super(ContactInformation, self).__init__(
            value, Tags.CONTACT_INFORMATION)


# 3.39
# TODO (peter-hamilton) A CustomAttribute TextString is not sufficient to
# TODO (peter-hamilton) cover all potential custom attributes. This is a
# TODO (peter-hamilton) temporary stopgap.
class CustomAttribute(TextString):

    def __init__(self, value=None):
        super(CustomAttribute, self).__init__(value, Tags.ATTRIBUTE_VALUE)


class DerivationParameters(Struct):
    """
    A set of values needed for key or secret derivation.

    A structure containing optional fields describing certain cryptographic
    parameters to be used when performing key or secret derivation operations.
    """

    def __init__(self,
                 cryptographic_parameters=None,
                 initialization_vector=None,
                 derivation_data=None,
                 salt=None,
                 iteration_count=None):
        """
        Construct a DerivationParameters struct.

        Args:
            cryptographic_parameters (CryptographicParameters): A
                CryptographicParameters struct containing the settings for
                the derivation process. Optional, defaults to None. If not
                included, the CryptographicParameters associated with the
                managed object will be used instead.
            initialization_vector (bytes): The IV value to be used with the
                pseudo-random derivation function (PRF). Optional depending
                on the PRF, defaults to None.
            derivation_data (bytes): A data component to be used instead of
                or with a derivation key to derive the new cryptographic
                object. Optional, defaults to None.
            salt (bytes): A salt value required by the PBKDF2 algorithm.
                Optional, defaults to None.
            iteration_count (bytes): An iteration count value required by
                the PBKDF2 algorithm. Optional, defaults to None.
        """
        super(DerivationParameters, self).__init__(
            tag=Tags.DERIVATION_PARAMETERS
        )

        self._cryptographic_parameters = None
        self._initialization_vector = None
        self._derivation_data = None
        self._salt = None
        self._iteration_count = None

        self.cryptographic_parameters = cryptographic_parameters
        self.initialization_vector = initialization_vector
        self.derivation_data = derivation_data
        self.salt = salt
        self.iteration_count = iteration_count

    @property
    def cryptographic_parameters(self):
        return self._cryptographic_parameters

    @cryptographic_parameters.setter
    def cryptographic_parameters(self, value):
        if value is None:
            self._cryptographic_parameters = None
        elif isinstance(value, CryptographicParameters):
            self._cryptographic_parameters = value
        else:
            raise TypeError(
                "cryptographic parameters must be a CryptographicParameters "
                "struct"
            )

    @property
    def initialization_vector(self):
        if self._initialization_vector:
            return self._initialization_vector.value
        else:
            return None

    @initialization_vector.setter
    def initialization_vector(self, value):
        if value is None:
            self._initialization_vector = None
        elif isinstance(value, six.binary_type):
            self._initialization_vector = ByteString(
                value=value,
                tag=enums.Tags.INITIALIZATION_VECTOR
            )
        else:
            raise TypeError("initialization vector must be bytes")

    @property
    def derivation_data(self):
        if self._derivation_data:
            return self._derivation_data.value
        else:
            return None

    @derivation_data.setter
    def derivation_data(self, value):
        if value is None:
            self._derivation_data = None
        elif isinstance(value, six.binary_type):
            self._derivation_data = ByteString(
                value=value,
                tag=enums.Tags.DERIVATION_DATA
            )
        else:
            raise TypeError("derivation data must be bytes")

    @property
    def salt(self):
        if self._salt:
            return self._salt.value
        else:
            return None

    @salt.setter
    def salt(self, value):
        if value is None:
            self._salt = None
        elif isinstance(value, six.binary_type):
            self._salt = ByteString(
                value=value,
                tag=enums.Tags.SALT
            )
        else:
            raise TypeError("salt must be bytes")

    @property
    def iteration_count(self):
        if self._iteration_count:
            return self._iteration_count.value
        else:
            return None

    @iteration_count.setter
    def iteration_count(self, value):
        if value is None:
            self._iteration_count = None
        elif isinstance(value, six.integer_types):
            self._iteration_count = Integer(
                value=value,
                tag=Tags.ITERATION_COUNT
            )
        else:
            raise TypeError("iteration count must be an integer")

    def read(self, input_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Read the data encoding the DerivationParameters struct and decode it
        into its constituent parts.

        Args:
            input_stream (stream): A data stream containing encoded object
                data, supporting a read method; usually a BytearrayStream
                object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be decoded. Optional,
                defaults to KMIP 1.0.
        """
        super(DerivationParameters, self).read(
            input_stream,
            kmip_version=kmip_version
        )
        local_stream = BytearrayStream(input_stream.read(self.length))

        if self.is_tag_next(
                enums.Tags.CRYPTOGRAPHIC_PARAMETERS,
                local_stream
        ):
            self._cryptographic_parameters = CryptographicParameters()
            self._cryptographic_parameters.read(
                local_stream,
                kmip_version=kmip_version
            )

        if self.is_tag_next(enums.Tags.INITIALIZATION_VECTOR, local_stream):
            self._initialization_vector = ByteString(
                tag=enums.Tags.INITIALIZATION_VECTOR
            )
            self._initialization_vector.read(
                local_stream,
                kmip_version=kmip_version
            )

        if self.is_tag_next(enums.Tags.DERIVATION_DATA, local_stream):
            self._derivation_data = ByteString(tag=enums.Tags.DERIVATION_DATA)
            self._derivation_data.read(local_stream, kmip_version=kmip_version)

        if self.is_tag_next(enums.Tags.SALT, local_stream):
            self._salt = ByteString(tag=enums.Tags.SALT)
            self._salt.read(local_stream, kmip_version=kmip_version)

        if self.is_tag_next(Tags.ITERATION_COUNT, local_stream):
            self._iteration_count = Integer(tag=Tags.ITERATION_COUNT)
            self._iteration_count.read(local_stream, kmip_version=kmip_version)

        self.is_oversized(local_stream)

    def write(self, output_stream, kmip_version=enums.KMIPVersion.KMIP_1_0):
        """
        Write the data encoding the DerivationParameters struct to a stream.

        Args:
            output_stream (stream): A data stream in which to encode object
                data, supporting a write method; usually a BytearrayStream
                object.
            kmip_version (KMIPVersion): An enumeration defining the KMIP
                version with which the object will be encoded. Optional,
                defaults to KMIP 1.0.
        """
        local_stream = BytearrayStream()

        if self._cryptographic_parameters:
            self._cryptographic_parameters.write(
                local_stream,
                kmip_version=kmip_version
            )
        if self._initialization_vector:
            self._initialization_vector.write(
                local_stream,
                kmip_version=kmip_version
            )
        if self._derivation_data:
            self._derivation_data.write(
                local_stream,
                kmip_version=kmip_version
            )
        if self._salt:
            self._salt.write(
                local_stream,
                kmip_version=kmip_version
            )
        if self._iteration_count:
            self._iteration_count.write(
                local_stream,
                kmip_version=kmip_version
            )

        self.length = local_stream.length()
        super(DerivationParameters, self).write(
            output_stream,
            kmip_version=kmip_version
        )
        output_stream.write(local_stream.buffer)

    def __eq__(self, other):
        if isinstance(other, DerivationParameters):
            if self.cryptographic_parameters != other.cryptographic_parameters:
                return False
            elif self.initialization_vector != other.initialization_vector:
                return False
            elif self.derivation_data != other.derivation_data:
                return False
            elif self.salt != other.salt:
                return False
            elif self.iteration_count != other.iteration_count:
                return False
            else:
                return True

    def __ne__(self, other):
        if isinstance(other, DerivationParameters):
            return not self == other
        else:
            return NotImplemented

    def __repr__(self):
        args = ", ".join([
            "cryptographic_parameters={0}".format(
                repr(self.cryptographic_parameters)
            ),
            "initialization_vector={0}".format(self.initialization_vector),
            "derivation_data={0}".format(self.derivation_data),
            "salt={0}".format(self.salt),
            "iteration_count={0}".format(
                self.iteration_count
            )
        ])
        return "DerivationParameters({0})".format(args)

    def __str__(self):
        return str({
            'cryptographic_parameters': self.cryptographic_parameters,
            'initialization_vector': self.initialization_vector,
            'derivation_data': self.derivation_data,
            'salt': self.salt,
            'iteration_count': self.iteration_count
        })
