"""Application configuration."""

import base64
import logging
import os
from os.path import abspath, dirname, join, pardir

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from dotenv import load_dotenv
from secrets_manager.flask_ext import FlaskSecretsManager

# Load environment variables from a .env file if present
dotenv_path = abspath(join(dirname(__file__), pardir, ".env"))
load_dotenv(dotenv_path)

# Service information
SERVICE_NAME = "ows-playlist"
SERVICE_VERSION = "1.0.0"

# Production environment
PROD_ENVIRONMENT = "prod"
DEV_ENVIRONMENT = "dev"
QA_ENVIRONMENT = "qa"
TEST_ENVIRONMENT = "test"
ENVIRONMENT = os.environ.get("Environment") or DEV_ENVIRONMENT
secrets_manager_client = FlaskSecretsManager(
    application_context=False, environment=ENVIRONMENT, service_name=SERVICE_NAME
)

# Snowflake
SNOWFLAKE_ACCOUNT = os.environ.get("SNOWFLAKE_ACCOUNT")
SNOWFLAKE_USER = os.environ.get("SNOWFLAKE_USER")
SNOWFLAKE_ROLE = os.environ.get("SNOWFLAKE_ROLE")
SNOWFLAKE_WAREHOUSE = os.environ.get("SNOWFLAKE_WAREHOUSE")
SNOWFLAKE_SCHEMA = os.environ.get("SNOWFLAKE_SCHEMA", "DEV")
SNOWFLAKE_DATABASE = os.environ.get("SNOWFLAKE_DATABASE")

SNOWFLAKE_POOL_SIZE = 15  # UWSGI number of threads
SNOWFLAKE_POOL_RECYCLE = 4 * 55 * 60  # Snowflake timeout: ~4 hours
SNOWFLAKE_POOL_MAX_OVERFLOW = 5
SNOWFLAKE_POOL_PRE_PING = False
SNOWFLAKE_POOL_RESET_ON_RETURN = None

if ENVIRONMENT == DEV_ENVIRONMENT:
    SNOWFLAKE_PRIVATE_KEY_PATH = os.environ["HOME"] + "/.ssh/snowflake/rsa_key.p8"
    try:
        SNOWFLAKE_PRIVATE_KEY_PATH = (
            secrets_manager_client.get_cred("SNOWFLAKE_PRIVATE_KEY_PATH")
            or SNOWFLAKE_PRIVATE_KEY_PATH
        )
        SNOWFLAKE_KEY_PASSPHRASE = (
            secrets_manager_client.get_cred("SNOWFLAKE_KEY_PASSPHRASE") or None
        )
    except Exception:
        SNOWFLAKE_KEY_PASSPHRASE = None

    with open(SNOWFLAKE_PRIVATE_KEY_PATH, "rb") as key:
        p_key = serialization.load_pem_private_key(
            key.read(),
            password=(
                SNOWFLAKE_KEY_PASSPHRASE.encode() if SNOWFLAKE_KEY_PASSPHRASE else None
            ),
            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}
else:  # For QA and PROD environments we use Secrets Manager
    SNOWFLAKE_PRIVATE_KEY = (
        secrets_manager_client.get_cred("SNOWFLAKE_PRIVATE_KEY") or None
    )
    if (
        not SNOWFLAKE_PRIVATE_KEY or SNOWFLAKE_PRIVATE_KEY == "dummy"
    ):  # default value set by Terraform when you create a secret  # noqa
        SNOWFLAKE_CONNECT_ARGS = {}
    else:
        SNOWFLAKE_CONNECT_ARGS = {
            "private_key": base64.b64decode(
                bytes(SNOWFLAKE_PRIVATE_KEY, encoding="utf-8")
            )
        }
        logging.info("Snowflake private key is set from Secrets Manager.")

REDIS_HOST = os.environ.get("REDIS_HOST")
REDIS_PORT = 6379
REDIS_USE_SSL = bool(os.environ.get("REDIS_USE_SSL", False))

# Errors and loggers
SENTRY = secrets_manager_client.get_cred("SENTRY_DSN")
if not SENTRY and ENVIRONMENT in [PROD_ENVIRONMENT, QA_ENVIRONMENT]:  # pragma: no cover
    raise Exception(f"Sentry is not configured in {ENVIRONMENT}")

LOGGER_LEVEL = logging.INFO
LOGGER_NAME = "ows1"

# Generic handlers
HEALTH_CHECK = "/hello/"

# Swagger documentation path
SWAGGER_FILE_PATH = "spec/ows_playlist-1.0.0.yaml"