"""validation handler."""
from typing import Callable, Dict, List
import uuid

import config
from ddex_ingester_common.constants.catalog_ingestion import REJECT
from ddex_ingester_common.helpers.s3_ddex import load_ddex_json
from ddex_ingester_common.logging import utils as logging_utils
from ddex_ingester_common.schemas.state_machine_schema import (
    StateMachineSchema
)
from ddex_ingester_common.validation.rules import get_validation_rules, \
    RuleResult
from ddex_ingester_common.validation.utils import save_validation_result
from lambdacommon.graphql import graphql


class ValidationRuleException(Exception):
    """ValidationRuleException exception."""


logger = logging_utils.get_logger(config.app_logger)


def handler(event: Dict, context: Dict) -> Dict:
    """Lambda entry point."""
    state_machine_data = StateMachineSchema().load(event)
    correlation_id = state_machine_data.correlation_id or str(uuid.uuid4())
    state_machine_data.correlation_id = correlation_id

    logging_utils.update_logger_correlation_id(logger, correlation_id)
    logging_utils.update_logger_with_message_ids(
        logger,
        state_machine_data.message_id,
        state_machine_data.message_thread_id,
        state_machine_data.execution_name
    )
    config.graphql_gateway.set_headers(
        {
            'Orchard-User-Id': config.OA_USER,
            'Correlation-Id': correlation_id,
        }
    )
    split = config.split_client

    rules = get_validation_rules(event.get('ddex_provider'),
                                 config.APPLICATION_NAME, split,
                                 config.graphql_gateway)

    # Execute validation against S3 parsed_json
    validation_results = validate(load_ddex_json(event), rules)

    results = save_validation_result(
        validation_results,
        state_machine_data.state_machine_name,
        state_machine_data.execution_name,
        config.catalog_ingestion_session
    )

    rejected_rules = [
        result.message for result in results if result.response == REJECT
    ]
    if rejected_rules:
        raise ValidationRuleException(rejected_rules)

    state_machine_data.correlation_id = correlation_id
    return StateMachineSchema().dump(state_machine_data)


def validate(
    data: Dict,
    rules: List[Callable[[Dict], RuleResult]]
) -> List[RuleResult]:
    """Validate incoming data against a set of rules."""
    validation_results = []
    for rule in rules:
        try:
            logger.info(f'Executing validation rule: {rule.__name__}')
            validation_results.append(rule(data))
        except graphql.GraphQLError:
            msg = f'GraphQL error while executing rule: {rule.__name__}'
            logger.error(msg)
            raise
        except Exception:
            msg = f'Exception while executing rule: {rule.__name__}'
            logger.error(msg)
            raise
    return validation_results