"""Config file for new_release_json_blaster."""

import base64
import logging
import os

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

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

APPLICATION_NAME = "lambda-releases-orcd-new-release-json-blaster"
PROD_ENVIRONMENT = "prod"
DEV_ENVIRONMENT = "dev"
QA_ENVIRONMENT = "qa"
TEST_ENVIRONMENT = "test"
ENVIRONMENT = os.environ.get("Environment", DEV_ENVIRONMENT)

LOCAL_SWAGGER_SPEC_PATH = "spec/swagger.yaml"

US_PHYSICAL_NEW_RELEASE_VIEW_QUERY = (
    f"SELECT * FROM sony_internal.{ENVIRONMENT}.us_physical_new_release_view"
)

# there is no dev-orchardbucket, only test, qa, and prod
S3_BUCKET = "{}-orcdbucket".format(
    TEST_ENVIRONMENT if ENVIRONMENT == DEV_ENVIRONMENT else ENVIRONMENT
)
BASE_S3_KEY = "releases.theorchard.com/{}"
NEW_RELEASE_DATA_S3_KEY = BASE_S3_KEY.format("data.json")
SWAGGER_SPEC_S3_KEY = BASE_S3_KEY.format("swagger.yaml")

# Snowflake
SNOWFLAKE_OPTIONS = {
    "role": os.environ.get("SNOWFLAKE_ROLE"),
    "account": os.environ.get("SNOWFLAKE_ACCOUNT"),
    "user": os.environ.get("SNOWFLAKE_USER"),
    "password": "dummy",
    "db": os.environ.get("SNOWFLAKE_DATABASE"),
    "schema": os.environ.get("SNOWFLAKE_SCHEMA"),
    "warehouse": os.environ.get("SNOWFLAKE_WAREHOUSE"),
}

# Snowflake SSH-Keypair access
SNOWFLAKE_CONNECT_ARGS = {}
SNOWFLAKE_PRIVATE_KEY_PATH = os.environ.get("SNOWFLAKE_PRIVATE_KEY_PATH", "")
SNOWFLAKE_KEY_PASSPHRASE = os.environ.get("SNOWFLAKE_KEY_PASSPHRASE", "")
if ENVIRONMENT == DEV_ENVIRONMENT and SNOWFLAKE_KEY_PASSPHRASE:
    if not SNOWFLAKE_PRIVATE_KEY_PATH:
        SNOWFLAKE_PRIVATE_KEY_PATH = (
            f"{os.environ.get('HOME', '')}/.ssh/snowflake/rsa_key.p8"
        )
    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(),
        )

    pkb = p_key.private_bytes(
        encoding=serialization.Encoding.DER,
        format=serialization.PrivateFormat.PKCS8,
        encryption_algorithm=serialization.NoEncryption(),
    )
    SNOWFLAKE_CONNECT_ARGS = {"private_key": pkb}

if ENVIRONMENT in [QA_ENVIRONMENT, PROD_ENVIRONMENT]:
    assert SNOWFLAKE_OPTIONS["user"]
    secrets_manager_client = LambdaSecretsManager(
        environment=ENVIRONMENT, service_name=APPLICATION_NAME
    )
    SNOWFLAKE_PRIVATE_KEY = secrets_manager_client.get_cred("SNOWFLAKE_PRIVATE_KEY")
    if SNOWFLAKE_PRIVATE_KEY:
        SNOWFLAKE_CONNECT_ARGS = {
            "private_key": base64.b64decode(
                bytes(SNOWFLAKE_PRIVATE_KEY, encoding="utf-8")
            )
        }

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