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

"""License text"""

import logging
from . import sss_api as apis
from .keystore import KeyStore
from .keyobject import KeyObject
from .getkey import Get
from .util import get_ecc_cypher_type

log = logging.getLogger(__name__)


class Generate:
    """
    Generate key pair/public key of ecc/rsa
    """

    def __init__(self, session_obj):
        """
        Constructor
        :param session_obj: Instance of session
        """
        self._session = session_obj
        self._ctx_ks = KeyStore(self._session)
        self._ctx_key = KeyObject(self._ctx_ks)
        self.key_obj_mode = apis.kKeyObject_Mode_Persistent

    def gen_ecc_public(self, key_id, curve_type, file_name, policy, encode_format=""):  # pylint: disable=too-many-arguments
        """
        Generate ecc public key
        :param key_id: Key index
        :param curve_type: ECC curve type
        :param file_name: File name to store public key
        :param policy: Policy to be applied
        :param encode_format: File format to store public key
        :return: Status
        """
        if file_name[-4:] != '.pem' and file_name[-4:] != '.der':
            log.error("Unsupported file type. File type should be in pem or der format")
            return apis.kStatus_SSS_Fail

        status = self.gen_ecc_pair(key_id, curve_type, policy)
        if status != apis.kStatus_SSS_Success:
            return status

        get = Get(self._session)
        status = get.get_key(key_id, file_name, encode_format)
        return status

    def gen_ecc_pair(self, key_id, curve_type, policy):
        """
        Generate ecc key pair
        :param key_id: Key index
        :param curve_type: ECC curve type
        :param policy: Policy to be applied
        :return: Status
        """
        cypher_type, key_size = get_ecc_cypher_type(curve_type)
        key_type = apis.kSSS_KeyPart_Pair
        if key_size == 0:
            log.error("curve type not supported")
            return apis.kStatus_SSS_Fail
        status = self._gen_key_pair(key_id, key_size, key_type, cypher_type, policy)
        return status

    def gen_rsa_public(self, key_id, key_size, file_name, policy):
        """
        Generate rsa public key
        :param key_id: Key index
        :param key_size: Key size to generate
        :param file_name: File name to store public key
        :param policy: Policy to be applied
        :return: Status
        """
        if file_name[-4:] != '.pem' and file_name[-4:] != '.der':
            log.error("Unsupported file type. File type should be in pem or der format")
            return apis.kStatus_SSS_Fail

        status = self.gen_rsa_pair(key_id, key_size, policy)
        if status != apis.kStatus_SSS_Success:
            return status

        get = Get(self._session)
        status = get.get_key(key_id, file_name)
        return status

    def gen_rsa_pair(self, key_id, key_size, policy):
        """
        Generate rsa key pair
        :param key_id: Key index
        :param key_size: RSA key size to generate
        :param policy: Policy to be applied
        :return: Status
        """
        key_type = apis.kSSS_KeyPart_Pair
        cypher_type = apis.kSSS_CipherType_RSA_CRT
        status = self._gen_key_pair(key_id, key_size, key_type, cypher_type, policy)
        return status

    def _gen_key_pair(self, key_id, key_size, key_type, cypher_type, policy):  # pylint: disable=too-many-arguments
        """
        Generate key pair
        :param key_id: Key index
        :param key_size: Key size
        :param key_type: Key type
        :param cypher_type: Cypher type
        :param policy: Policy to be applied
        :return: Status
        """

        # Key length calculation based on key bit length
        # if modulus of key_bit_len is non zero, then allocate extra byte
        if (key_size % 8) != 0:
            key_len = (key_size / 8) + 1
        else:
            key_len = key_size / 8

        status = self._ctx_key.allocate_handle(key_id, key_type, cypher_type, int(key_len),
                                               self.key_obj_mode)
        if status != apis.kStatus_SSS_Success:
            return status

        status = self._ctx_ks.generate_key(self._ctx_key, key_size, policy)
        if status != apis.kStatus_SSS_Success:
            return status

        status = self._ctx_ks.save_key_store()
        return status