"""Config file for lambda function."""

import logging
import os
import sys

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from secrets_manager.lambda_ext import LambdaSecretsManager
import sentry_sdk
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from sentry_sdk.integrations.logging import LoggingIntegration

LAMBDA_NAME = 'lambda-dd-snowflake-sync'

# AWS region configuration
DEFAULT_AWS_REGION = 'us-east-1'
AWS_REGION = os.environ.get('AWS_REGION', DEFAULT_AWS_REGION)

# Environment setup
TEST_ENVIRONMENT = 'test'
QA_ENVIRONMENT = 'qa'
PROD_ENVIRONMENT = 'prod'
ENVIRONMENT = os.environ.get('ENVIRONMENT', QA_ENVIRONMENT)

LOGGER_LEVEL = os.environ.get('LOGGER_LEVEL', logging.INFO)

# Sentry Config
SENTRY_DSN = os.environ.get('SENTRY_DSN') or None
if SENTRY_DSN:
    sentry_sdk.init(
        dsn=SENTRY_DSN,
        environment=ENVIRONMENT,
        integrations=[
            LoggingIntegration(
                level=LOGGER_LEVEL,
                event_level=None  # Don't send error log as sentry event.
            ),
            AwsLambdaIntegration()
        ])

secrets_manager_client = LambdaSecretsManager(
    environment=ENVIRONMENT,
    service_name=LAMBDA_NAME
)


def load_private_key():
    """Load the Snowflake private key based on the environment."""
    if ENVIRONMENT == TEST_ENVIRONMENT:
        return None

    if ENVIRONMENT in [QA_ENVIRONMENT, PROD_ENVIRONMENT]:
        private_key = secrets_manager_client.get_cred(
            'SNOWFLAKE_PRIVATE_KEY'
        )
        private_key_passphrase = secrets_manager_client.get_cred(
            'SNOWFLAKE_PRIVATE_KEY_PASSPHRASE'
        )
    else:
        # For local development only
        snowflake_private_key_location = os.environ.get(
            'SNOWFLAKE_PRIVATE_KEY_LOCATION'
        )
        with open(snowflake_private_key_location) as fo:
            private_key = fo.read()
        private_key_passphrase = os.environ.get(
            'SNOWFLAKE_PRIVATE_KEY_PASSPHRASE'
        )

    private_key = serialization.load_pem_private_key(
        private_key.encode(),
        password=private_key_passphrase.encode(),
        backend=default_backend()
    )

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


SNOWFLAKE_USER = os.environ.get('SNOWFLAKE_USER')
SNOWFLAKE_ACCOUNT = os.environ.get('SNOWFLAKE_ACCOUNT')
SNOWFLAKE_ROLE = os.environ.get('SNOWFLAKE_ROLE')
SNOWFLAKE_WAREHOUSE = os.environ.get('SNOWFLAKE_WAREHOUSE')
SNOWFLAKE_DATABASE = os.environ.get('SNOWFLAKE_DATABASE')
SNOWFLAKE_SCHEMA = os.environ.get('SNOWFLAKE_SCHEMA')

SNOWFLAKE_CONFIG = {
    'user': SNOWFLAKE_USER,
    'account': SNOWFLAKE_ACCOUNT,
    'database': SNOWFLAKE_DATABASE,
    'schema': SNOWFLAKE_SCHEMA,
    'warehouse': SNOWFLAKE_WAREHOUSE,
    'role': SNOWFLAKE_ROLE,
    'private_key': load_private_key(),
}

TABLES_TO_LOG = os.environ.get('TABLES_TO_LOG', '')

logger = logging.getLogger()
logger.setLevel(LOGGER_LEVEL)
stream_handler = logging.StreamHandler(sys.stdout)
stream_handler.setLevel(logging.DEBUG)
logger.handlers = [stream_handler]