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

from __future__ import annotations

import logging
import os
from typing import TypedDict

from abacus_common_logic.utils.ssh import get_private_key
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from dotenv import load_dotenv
from secrets_manager.lambda_ext import LambdaSecretsManager

# Load environment variables from a .env file if present
load_dotenv(override=True)


class SnowflakeConfig(TypedDict):
    """Snowflake connection configuration."""

    account: str
    db: str
    role: str
    schema: str
    user: str
    warehouse: str
    private_key: str


APPLICATION_NAME = 'lambda-abacus-adjustments-json-validation'

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

# Environment setup
DEV_ENVIRONMENT = 'dev'
QA_ENVIRONMENT = 'qa'
UAT_ENVIRONMENT = 'uat'
PROD_ENVIRONMENT = 'prod'
ENVIRONMENT = os.environ.get('ENVIRONMENT', DEV_ENVIRONMENT)

# Logger setup
LOGGING_LEVEL = os.environ.get('LOGGING_LEVEL', logging.INFO)
LOGGER_DSN = os.environ.get('LOGGER_DSN')
SENTRY_DSN = None

# S3
S3_BUCKET_NAME = os.environ.get('S3_BUCKET_NAME', 'qa-abacus-adjustments')
S3_ACCOUNT_ID = os.environ.get('S3_ACCOUNT_ID', '437795906767')

# Sentry
SENTRY_DSN = os.environ.get('SENTRY_DSN')

# Snowflake configuration
SNOWFLAKE_CONFIG: SnowflakeConfig = {
    'account': os.environ.get('SNOWFLAKE_ACCOUNT', ''),
    'db': os.environ.get('SNOWFLAKE_DATABASE', 'ROYALTY_ACCOUNTING'),
    'role': os.environ.get('SNOWFLAKE_ROLE', ''),
    'warehouse': os.environ.get('SNOWFLAKE_WAREHOUSE', ''),
    'schema': os.environ.get('SNOWFLAKE_SCHEMA', ENVIRONMENT),
    'user': os.environ.get('SNOWFLAKE_USER', ''),
    'private_key': '',
}

# Snowflake SSH-Keypair access
SNOWFLAKE_KEY_PASSPHRASE = os.environ.get('SNOWFLAKE_KEY_PASSPHRASE')
SNOWFLAKE_PRIVATE_KEY_PATH = os.environ.get('SNOWFLAKE_PRIVATE_KEY_PATH')
SNOWFLAKE_PRIVATE_KEY = os.environ.get('SNOWFLAKE_PRIVATE_KEY', None)

# Fivetran schema
FIVETRAN_SCHEMA_ENV = QA_ENVIRONMENT if ENVIRONMENT == DEV_ENVIRONMENT else ENVIRONMENT

FIVETRAN_SCHEMA = os.environ.get(
    'FIVETRAN_SCHEMA', f'{FIVETRAN_SCHEMA_ENV}_ROYALTY_ACCOUNTING_ROYALTY_ACCOUNTING'
)

# S3
S3_BUCKET_NAME = os.environ.get('S3_BUCKET_NAME', 'qa-abacus-adjustments')
S3_ACCOUNT_ID = os.environ.get('S3_ACCOUNT_ID', '437795906767')
ABACUS_ADJUSTMENTS_STAGE = os.environ.get(
    'ABACUS_ADJUSTMENTS_STAGE', 'ABACUS_ADJUSTMENTS_STAGE'
)

# Sentry
SENTRY_DSN = os.environ.get('SENTRY_DSN')

# Pull QA, UAT & Prod credentials from secrets manager
if ENVIRONMENT in [QA_ENVIRONMENT, UAT_ENVIRONMENT, PROD_ENVIRONMENT]:
    client = LambdaSecretsManager(
        environment=ENVIRONMENT, service_name=APPLICATION_NAME
    )

    SNOWFLAKE_KEY_PASSPHRASE = client.get_cred('SNOWFLAKE_KEY_PASSPHRASE')
    SNOWFLAKE_PRIVATE_KEY = client.get_cred('SNOWFLAKE_PRIVATE_KEY')

# For QA, UAT & Prod
if SNOWFLAKE_PRIVATE_KEY and SNOWFLAKE_KEY_PASSPHRASE:
    private_key = serialization.load_pem_private_key(
        bytes(SNOWFLAKE_PRIVATE_KEY, 'utf8'),
        password=bytes(SNOWFLAKE_KEY_PASSPHRASE, 'utf8'),
        backend=default_backend(),
    )

    SNOWFLAKE_CONFIG['private_key'] = private_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption(),
    )  # type: ignore[typeddict-item]
# For local/dev env, get private key from local machine
elif SNOWFLAKE_PRIVATE_KEY_PATH and SNOWFLAKE_KEY_PASSPHRASE:
    SNOWFLAKE_CONFIG['private_key'] = get_private_key(
        SNOWFLAKE_PRIVATE_KEY_PATH.replace('~', os.environ['HOME']),
        SNOWFLAKE_KEY_PASSPHRASE,
    )