"""Application configuration."""

import logging
import os
from urllib import parse

from owsclient import OwsClient
from owsrequest.ows_client import correlation_id_getter, request_context_getter
from python_pdp_sdk.backends.authorization_backend import (
    AuthorizationBackend,
    PdpAuthorizationBackend,
)
from python_pdp_sdk.connectors.ows_pdp.ows_pdp import OwsPdpClient
from secrets_manager.python_ext import PythonSecretsManager

# Service information
SERVICE_NAME = "ows-product-review"
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

AWS_DEFAULT_REGION = os.environ.get("AWS_DEFAULT_REGION", "us-east-1")
AWS_REGION = os.environ.get("AWS_REGION", AWS_DEFAULT_REGION)


def get_ows_client(environment) -> OwsClient:
    """Set up ows-client."""
    return OwsClient(
        environment=environment,
        service_name=SERVICE_NAME,
        correlation_id_getter=correlation_id_getter,
        request_context_getter=request_context_getter,
    )


def get_pdp_authorization_backend(ows_client: OwsClient) -> AuthorizationBackend:
    """Set up Authorization Backend."""
    ows_pdp_client = OwsPdpClient(ows_client=ows_client)
    return PdpAuthorizationBackend(ows_pdp_client)


ows_client = get_ows_client(ENVIRONMENT)
pdp_authorization_backend = get_pdp_authorization_backend(ows_client)

secrets_manager_client = PythonSecretsManager(
    application_context=False,
    environment=ENVIRONMENT,
    service_name=SERVICE_NAME,
    force_remote=(ENVIRONMENT not in (DEV_ENVIRONMENT, TEST_ENVIRONMENT)),
)


def get_cred_value(cred_name):
    """Return secrets value for given cred_name."""
    return secrets_manager_client.get_cred(cred_name)


SENTRY = os.environ.get("SENTRY_DSN") or None
if not SENTRY:
    SENTRY = get_cred_value("SENTRY_DSN")

# Database config
MYSQL_DB_PASS = os.environ.get("MYSQL_DB_PASS") or None
if not MYSQL_DB_PASS:
    MYSQL_DB_PASS = get_cred_value("MYSQL_DB_PASS")
MYSQL_DB_USER = os.environ.get("MYSQL_DB_USER")
MYSQL_DB_NAME = os.environ.get("MYSQL_DB_NAME")
MYSQL_DB_HOST = os.environ.get("MYSQL_DB_HOST")
MYSQL_DB_PORT = os.environ.get("MYSQL_DB_PORT", "3306")

# Art Relations config (QA Only)
AR_DB_USER = os.environ.get("AR_DB_USER")
AR_DB_NAME = os.environ.get("AR_DB_NAME")
AR_DB_HOST = os.environ.get("AR_DB_HOST")
AR_DB_PASS = os.environ.get("AR_DB_PASS", "")
if not AR_DB_PASS and ENVIRONMENT == QA_ENVIRONMENT:
    AR_DB_PASS = get_cred_value("AR_DB_PASS")
AR_DB_URL = "sqlite://"
if ENVIRONMENT in [DEV_ENVIRONMENT, QA_ENVIRONMENT]:
    AR_DB_URL = (
        "mysql+pymysql://"
        f"{AR_DB_USER}:{parse.quote(AR_DB_PASS.encode('utf-8'))}"
        f"@{AR_DB_HOST}"
        f"/{AR_DB_NAME}?charset=utf8"
    )

# SQLAlchemy Config
DB_URL = (
    "mysql+pymysql://"
    f"{MYSQL_DB_USER}:{MYSQL_DB_PASS}"
    f"@{MYSQL_DB_HOST}:{MYSQL_DB_PORT}"
    f"/{MYSQL_DB_NAME}?charset=utf8mb4"
)
SQLALCHEMY_TRACK_MODIFICATIONS = False
if ENVIRONMENT == TEST_ENVIRONMENT:
    DB_URL = "sqlite://"
    SQLALCHEMY_TRACK_MODIFICATIONS = False


SQLALCHEMY_ENGINE_OPTIONS = {
    "pool_size": 15,
    "pool_recycle": 3600,  # Avoids connections going stale
    "max_overflow": 0,
}
if ENVIRONMENT in (DEV_ENVIRONMENT, TEST_ENVIRONMENT):
    SQLALCHEMY_ENGINE_OPTIONS = {}

DB_CONFIG = {
    "SQLALCHEMY_DATABASE_URI": DB_URL,
    "SQLALCHEMY_TRACK_MODIFICATIONS": SQLALCHEMY_TRACK_MODIFICATIONS,
    "SQLALCHEMY_ENGINE_OPTIONS": SQLALCHEMY_ENGINE_OPTIONS,
}

if ENVIRONMENT in {DEV_ENVIRONMENT, QA_ENVIRONMENT, TEST_ENVIRONMENT}:
    DB_CONFIG["SQLALCHEMY_BINDS"] = {"art_relations": AR_DB_URL}

GRAPHQL_ENVIRONMENT = ENVIRONMENT if ENVIRONMENT != DEV_ENVIRONMENT else QA_ENVIRONMENT
GRAPHQL_URL = f'https://{GRAPHQL_ENVIRONMENT}-graphql-router.theorchard.io/graphql'

# Errors and loggers
LOGGER_LEVEL = os.environ.get("LOGGER_LEVEL", logging.INFO)
LOGGER_NAME = "ows1"

# Generic handlers
HEALTH_CHECK = "/hello/"

ONLY_LOG_ACCESS_ERRORS = True

KAFKA_BOOTSTRAP_SERVERS = os.environ.get("KAFKA_BOOTSTRAP_SERVERS")
KAFKA_SECURITY_PROTOCOL = os.environ.get("KAFKA_SECURITY_PROTOCOL", "SSL")
KAFKA_REVIEW_TOPIC = "event.owsContentReview.review"
KAFKA_PRODUCT_TOPIC = "event.owsContentReview.product"

SFN_COMPLETE_REVIEW_ARN = os.environ.get("SFN_COMPLETE_REVIEW_ARN")
SFN_COMPLETE_REVIEW_V2_ARN = os.environ.get("SFN_COMPLETE_REVIEW_V2_ARN")

VAPI_BASE_URL = os.environ.get("VAPI_BASE_URL")
VAPI_CLIENT_ID = os.environ.get("VAPI_CLIENT_ID")
VAPI_CLIENT_SECRET = os.environ.get("VAPI_CLIENT_SECRET") or None
if not VAPI_CLIENT_SECRET:
    VAPI_CLIENT_SECRET = get_cred_value("VAPI_CLIENT_SECRET")
VAPI_REDIRECT_URI = os.environ.get("VAPI_REDIRECT_URI")
VAPI_USER_ID = os.environ.get("VAPI_USER_ID")
VAPI_USER_TYPE = os.environ.get("VAPI_USER_TYPE")