#
# Copyright 2018-2020 NXP
# SPDX-License-Identifier: Apache-2.0
#
#

"""License text"""

import ctypes
import logging
from . import sss_api as apis
from .keystore import KeyStore
from .keyobject import KeyObject
from .util import status_to_str

log = logging.getLogger(__name__)


class DeriveKey:  # pylint: disable=too-many-instance-attributes
    """
    Key derivation operation
    """

    def __init__(self, session_obj, host_session_obj=None):
        """
        Constuctor
        :param session_obj: Instance of session
        :param host_session_obj: Instance of host session
        """
        self._session = session_obj.session_ctx
        self.derive = apis.sss_derive_key_t()
        self.algorithm = apis.kAlgorithm_SSS_ECDH
        self.mode = apis.kMode_SSS_ComputeSharedSecret
        self.derived_key = None
        self._ctx_ks = KeyStore(session_obj)
        self._ctx_key = KeyObject(self._ctx_ks)
        self.derived_key = None
        self.object_type = apis.kSSS_KeyPart_Default
        self.cypher_type = apis.kSSS_CipherType_HMAC
        if host_session_obj is not None:
            self._host_session = host_session_obj.session_ctx
            self._host_ctx_ks = KeyStore(host_session_obj)
            self._host_ctx_key = KeyObject(self._host_ctx_ks)

    def _symmetric_context_init(self, key_id, prv_key_obj):
        """
        asymmetric context initialization
        :param key_id: Key index
        :param prv_key_obj: key object of private key
        :return: Status
        """
        data_len = 80
        cypher_type = apis.kSSS_CipherType_AES

        status = self._ctx_key.allocate_handle(key_id, self.object_type, cypher_type, data_len,
                                               apis.kKeyObject_Mode_Transient)

        if status != apis.kStatus_SSS_Success:
            return status

        status = apis.sss_derive_key_context_init(ctypes.byref(self.derive),
                                                  ctypes.byref(self._session),
                                                  ctypes.byref(prv_key_obj.keyobject),
                                                  self.algorithm, self.mode)
        if status != apis.kStatus_SSS_Success:
            log.error("sss_derive_key_context_init %s", status_to_str(status))
        return status

    def symmetric_derive_ka(self, key_id, prv_key_obj, pub_key_obj):
        """
        Asymmetric derive key agreement
        :param key_id: Key index
        :param prv_key_obj: Key object of private key
        :param pub_key_obj: Key object of public key
        :return: Status
        """
        self.algorithm = apis.kAlgorithm_SSS_ECDH

        status = self._symmetric_context_init(key_id, prv_key_obj)
        if status != apis.kStatus_SSS_Success:
            return status

        status = apis.sss_derive_key_dh(ctypes.byref(self.derive),
                                        ctypes.byref(pub_key_obj.keyobject),
                                        ctypes.byref(self._ctx_key.keyobject))
        if status != apis.kStatus_SSS_Success:
            log.error("sss_derive_key_dh %s", status_to_str(status))

        return status

    def symmetric_derive_kd(self, key_id, prv_key_obj, salt, info, req_key_len):  # pylint: disable=too-many-arguments

        """
        Asymmetric derive key derivation
        :param key_id: Key index
        :param prv_key_obj: Key object of private key
        :param salt: Salt data
        :param info: Info data
        :param req_key_len: Request key length
        :param derive_key_file: File name to store derived key
        :return: Status
        """

        self.algorithm = apis.kAlgorithm_SSS_HMAC_SHA256
        status = self._symmetric_context_init(key_id, prv_key_obj)
        if status != apis.kStatus_SSS_Success:
            return status
        salt_len = len(salt)
        info_len = len(info)
        salt_ctype = (ctypes.c_uint8 * salt_len)(*salt)
        info_ctype = (ctypes.c_uint8 * info_len)(*info)

        status = self._host_ctx_key.allocate_handle(key_id, self.object_type,
                                                    self.cypher_type, req_key_len,
                                                    apis.kKeyObject_Mode_Persistent)
        if status != apis.kStatus_SSS_Success:
            return status

        status = apis.sss_derive_key_one_go(ctypes.byref(self.derive), salt_ctype, salt_len,
                                            info_ctype, info_len,
                                            ctypes.byref(self._host_ctx_key.keyobject),
                                            req_key_len)
        if status != apis.kStatus_SSS_Success:
            log.error("sss_derive_key_dh %s", status_to_str(status))

        return status