"""Helper functions."""
import base64
import os

import config
from botocore.exceptions import ClientError
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from secrets_manager.lambda_ext import LambdaSecretsManager


def get_secret(service_name: str, secret_name: str):
    """Get secret value from LambdaSecretsManager.

    For dev environment it loads value from environ instead of secrets manager.

    Args:
        service_name: service name defined in terraform configuration
        secret_name: key name for the secret
    Returns:
        secrets value or None if secrets not created
    """
    secrets_manager_client = LambdaSecretsManager(
        environment=config.ENVIRONMENT, service_name=service_name)
    try:
        return secrets_manager_client.get_cred(secret_name)
    except ClientError as e:
        # The secret is empty
        if e.response['Error']['Code'] == 'ResourceNotFoundException':
            return None
        else:
            raise e


def get_sf_private_key(secrets_path: str):
    """Return Snowflake private_key.

    Args:
        secrets_path (str): Secrets manager path of the flow.
    Returns:
        str: Snowflake private_key.
    """
    private_key = None
    private_key_string = get_secret(secrets_path, 'SNOWFLAKE_KEY')
    if private_key_string:
        private_key = base64.b64decode(
            bytes(private_key_string, encoding='utf-8'))

    if not private_key and config.ENVIRONMENT == 'dev':
        # Default for local dev
        snowflake_private_key_path = os.environ['HOME'] + \
            '/.ssh/snowflake/rsa_key.p8'
        snowflake_private_key_path = os.environ.get(
            'SNOWFLAKE_PRIVATE_KEY_PATH', snowflake_private_key_path)
        snowflake_key_passphrase = os.environ.get(
            'SNOWFLAKE_KEY_PASSPHRASE', None)
        if snowflake_key_passphrase:
            with open(snowflake_private_key_path, 'rb') as key:
                p_key = serialization.load_pem_private_key(
                    key.read(),
                    password=snowflake_key_passphrase.encode(),
                    backend=default_backend()
                )

            private_key = p_key.private_bytes(
                encoding=serialization.Encoding.DER,
                format=serialization.PrivateFormat.PKCS8,
                encryption_algorithm=serialization.NoEncryption())

    return private_key