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

import base64
import os
from logging import INFO, getLogger

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from owsclient import M2MTokenManager, OwsClient
from secrets_manager.python_ext import PythonSecretsManager
from sentry_sdk import init
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration
from sentry_sdk.integrations.logging import LoggingIntegration

APPLICATION_NAME = "lambda-product-transfer-update-dim-tables"

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

# Environment setup
QA_ENVIRONMENT = "qa"
PROD_ENVIRONMENT = "prod"
ENVIRONMENT: str = os.environ.get("ENVIRONMENT", QA_ENVIRONMENT)

# Logging
LOGGER_LEVEL = int(os.environ.get("LOGGER_LEVEL", INFO))
logger = getLogger()
logger.setLevel(LOGGER_LEVEL)

SENTRY_DSN = os.environ.get("SENTRY_DSN")
if SENTRY_DSN:
    init(
        dsn=SENTRY_DSN,
        environment=ENVIRONMENT,
        integrations=[
            AwsLambdaIntegration(),
            LoggingIntegration(level=LOGGER_LEVEL, event_level=None),
        ],
    )

secrets_manager_client = PythonSecretsManager(
    environment=ENVIRONMENT,
    service_name=APPLICATION_NAME,
)

m2m_token_manager = M2MTokenManager(
    secrets_manager=secrets_manager_client,
    environment=ENVIRONMENT,
    service_name=APPLICATION_NAME,
)

ows_client = OwsClient(
    environment=ENVIRONMENT,
    service_name=APPLICATION_NAME,
    m2m_token_manager=m2m_token_manager,
)

SNOWFLAKE_USER_NAME: str | None = os.environ.get("SNOWFLAKE_USER_NAME")
SNOWFLAKE_ACCOUNT: str = os.environ.get("SNOWFLAKE_ACCOUNT", "delphi")
SNOWFLAKE_ROLE: str | None = os.environ.get("SNOWFLAKE_ROLE")
SNOWFLAKE_SCHEMA: str = os.environ.get("SNOWFLAKE_SCHEMA", "QA")


def get_snowflake_private_key() -> bytes | None:
    key_path = os.environ.get("SNOWFLAKE_PRIVATE_KEY_PATH")
    passphrase = os.environ.get("SNOWFLAKE_KEY_PASSPHRASE")
    if key_path and passphrase:
        with open(key_path, "rb") as f:
            p_key = serialization.load_pem_private_key(
                f.read(), password=passphrase.encode(), backend=default_backend()
            )
        return p_key.private_bytes(
            encoding=serialization.Encoding.DER,
            format=serialization.PrivateFormat.PKCS8,
            encryption_algorithm=serialization.NoEncryption(),
        )
    sm_key = secrets_manager_client.get_cred("SNOWFLAKE_PRIVATE_KEY") or None
    return base64.b64decode(sm_key.encode()) if sm_key else None