"""Application.

The API application is a `flask` application. It provides simple features such
as registering a url for a specific handlers.
"""

import connector_neo4j
from confluent_kafka.serialization import StringSerializer
from flask import Flask
from kafka_utils.producer.event import EventProducer
from kafka_utils.producer.serializer.simple_json import SimpleJSONSerializer
from owsclient import OwsClient
from owslogger import flask_logger, logger
from owsrequest import flask_request
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 pythonfeatures import pythonfeatures
from pythonfeatures.constants import split as split_constants  # noqa

from account import config

app = Flask(config.SERVICE_NAME)
flask_logger.setup(
    app,
    config.ENVIRONMENT,
    config.LOGGER_NAME,
    config.LOGGER_LEVEL,
    config.SERVICE_NAME,
    config.SERVICE_VERSION,
    exclude_paths=[config.HEALTH_CHECK],
)
logger.setup(
    config.ENVIRONMENT,
    'owsrequest',
    config.LOGGER_LEVEL,
    config.SERVICE_NAME,
    config.SERVICE_VERSION,
)
flask_request.set_rules_validator(app, 'account/access_rules.yml')
flask_request.setup(
    app,
    config.ENVIRONMENT,
    add_request_context=True,
    label_profile=True,
    verify_access=False,
    rules_file=None,
    access_log_only=config.ONLY_LOG_ACCESS_ERRORS,
    exclude_paths=[
        config.HEALTH_CHECK,
        '/lookup/vendors/uuids/',
        '/lookup/vendors/vendor-ids/',
        '/lookup/vendors/features/uuids/',
        '/lookup/subaccounts/features/uuids/',
        '/lookup/subaccounts/uuids/',
        '/lookup/company-brands/uuids/',
    ],
    uwsgi_cache_enabled=True,
)

is_enabled = (
    pythonfeatures.get_single_feature_by_attributes('neo4j_aura', {'service': config.SERVICE_NAME})
).message == split_constants.FEATURE_ENABLED
if is_enabled:
    neo4j_username = config.NEO4J_AURA_USERNAME
    neo4j_password = config.NEO4J_AURA_PASSWORD
    neo4j_url = config.NEO4J_AURA_URL
else:
    neo4j_username = config.NEO4J_USERNAME
    neo4j_password = config.NEO4J_PASSWORD
    neo4j_url = config.NEO4J_URL

connector_neo4j.configure(
    neo4j_url,
    neo4j_username,
    neo4j_password,
    max_transaction_retry_time=config.NEO4J_MAX_RETRY_TIME,
)

if config.ENVIRONMENT in [config.QA_ENVIRONMENT, config.PROD_ENVIRONMENT]:
    if not config.KAFKA_BOOTSTRAP_SERVERS:
        raise Exception(f'Kafka producer is not configured in {config.ENVIRONMENT}')


def setup_producer():
    """Set up producer."""
    return EventProducer(
        config.KAFKA_BOOTSTRAP_SERVERS,
        StringSerializer(),
        SimpleJSONSerializer(),
        config.KAFKA_SECURITY_PROTOCOL,
        {'message.timeout.ms': config.KAFKA_TIMEOUT},
    )


def setup_ows_client() -> OwsClient:
    """Setup ows-client."""
    return OwsClient(
        environment=config.ENVIRONMENT,
        service_name='ows-account',
        correlation_id_getter=correlation_id_getter,
        request_context_getter=request_context_getter,
    )


def setup_authorization_backend(ows_client: OwsClient) -> AuthorizationBackend:
    """Setup Authorization Backend."""
    ows_pdp_client = OwsPdpClient(ows_client=ows_client)
    return PdpAuthorizationBackend(ows_pdp_client)


# global event producer
kafka_producer = setup_producer()

# global ows-client
ows_client = setup_ows_client()

# global authorization backend
authorization_backend = setup_authorization_backend(ows_client)