"""Logic for Rule."""

from owsresponse import response
from redis import exceptions as redis_exceptions
from sentry_sdk import capture_exception

from vector_job_rules.connectors.redis import redis_client
from vector_job_rules.constants import error
from vector_job_rules.models import rule as rule_model


def get_rules(status=None, rule_ids=None):
    """Get rules.

    Restructure the get_rules response to consolidate rules and conditions.

    Args:
        status (str): inactive or active are acceptable values.
        rule_ids (tuple): A tuple filed with rule_id numbers.

    Returns:
        Response: the rules under items.

    """
    cache_exists = False

    try:
        cache_exists = redis_client.exists('ows_vector_job_rules')
    except (redis_exceptions.TimeoutError, redis_exceptions.ConnectionError) as err:
        capture_exception(err)

    if cache_exists:
        rules = rule_model.get_rules_from_cache(status=status, rule_ids=rule_ids)
    else:
        db_rules = rule_model.get_rules()

        formatted_rules = rule_model.format_rules_into_response_format(db_rules)

        rule_model.push_rules_into_cache(formatted_rules)

        rules = rule_model.filter_formatted_rules(
            formatted_rules, status=status, rule_ids=rule_ids
        )

    return response.Response({'items': rules.message})


def update_rules(data):
    """Update the rules.

    We want to update all the rows with new priority values. We expect all
    input dictionaries to have at least a rule_id and if priority is present
    then all rows must be present in the request. We will handle priority
    unique validation in the handler request body validation.

    Args:
        data (list(dict)): We have a list of updated document values.

    Returns:
        response.Response
    """
    existing_rules = get_rules()

    existing_rule_ids = [int(x['id']) for x in existing_rules.message['items']]
    request_rule_ids = [int(x['rule_id']) for x in data]

    if set(request_rule_ids) != set(existing_rule_ids):
        return response.create_error_response(
            code=error.ERROR_CODE_INVALID_REQUEST,
            message='Rule ids in request must match database.',
        )

    for rule in data:
        rule_model.update_rule(
            rule['rule_id'],
            priority=rule.get('priority'),
            description=rule.get('description'),
            updated_by=rule.get('updated_by'),
        )

    try:
        redis_client.flushall()
    except (redis_exceptions.TimeoutError, redis_exceptions.ConnectionError) as err:
        capture_exception(err)

    return response.Response(message='Rule priorities successfully updated.')