"""Logic module for conflict status."""

import datetime

from oto import response

from conflict_manager.constants import database as db_consts
from conflict_manager.constants import error as error_consts
from conflict_manager.constants import schema
from conflict_manager.models import conflict_status
from conflict_manager.models import fact_conflict


def _remove_duplicate_ids(ids):
    """
    Remove duplicates from grouped conflicts ids list.

    Args:
        ids (list): list of grouped conflicts ids
    Returns:
        list: list of unique grouped conflicts ids
    """
    return [dict(t) for t in set(tuple(id.items()) for id in ids)]


def bulk_update_conflict_status(
        *, user_id, grouped_conflicts_ids, status, note,
        account_type=None, account_id=None):
    """Update grouped conflict status.

    Args:
        user_id (int): Orchard user id
        grouped_conflicts_ids (list): list of grouped conflicts ids
        status (str): conflict status
        note (str): status note

    Returns:
        response.Response: result of operation
    """
    validation_response = validate_grouped_conflicts_ids(grouped_conflicts_ids)
    if not validation_response:
        return validation_response

    grouped_conflicts_ids = _remove_duplicate_ids(grouped_conflicts_ids)
    today = datetime.date.today().strftime(db_consts.SNOWFLAKE_DATE_FORMAT)
    ids = [id[db_consts.GROUPED_CONFLICT_ID] for id in grouped_conflicts_ids]
    ids = list(ids)
    ids_to_update = conflict_status.get_ids_to_update(ids)

    new_conflict_statuses = []
    for grouped_id in grouped_conflicts_ids:
        grouped_conflicts_id = grouped_id[db_consts.GROUPED_CONFLICT_ID]
        if grouped_conflicts_id not in ids_to_update:
            conflicts_status = dict(grouped_id)
            conflicts_status[db_consts.STATUS] = status
            conflicts_status[db_consts.UPDATE_DATE] = today
            conflicts_status[db_consts.USER_ID] = user_id
            conflicts_status[db_consts.NOTE] = note
            conflicts_status[db_consts.ACCOUNT_TYPE] = account_type
            conflicts_status[db_consts.ACCOUNT_ID] = account_id
            new_conflict_statuses.append(conflicts_status)

    if new_conflict_statuses:
        conflict_status.create(new_conflict_statuses)

    if ids_to_update:
        conflict_status.update(list(ids_to_update), status, today, note)

    return response.Response({
        schema.STATUS: status,
        schema.UPDATED_CONFLICTS_AMOUNT: len(grouped_conflicts_ids)})


def validate_grouped_conflicts_ids(grouped_conflicts):
    """Validate provided grouped conflicts ids.

    Args:
        grouped_conflicts: list of grouped conflicts ids

    Returns:
        response.Response: result of validation
    """
    existing_ids = fact_conflict.get_grouped_conflicts_ids(grouped_conflicts)
    invalid_ids = {}
    error = {
        schema.GROUPED_CONFLICTS_IDS: error_consts.INVALID_GROUPED_ID
    }
    for i, grouped_id in enumerate(grouped_conflicts):
        grouped_conflicts_id = grouped_id[db_consts.GROUPED_CONFLICT_ID]
        if grouped_conflicts_id not in existing_ids:
            invalid_ids[i] = error

    if invalid_ids:
        return response.create_error_response(
            code=error_consts.ERROR_CODE_VALIDATION,
            message={schema.GROUPED_CONFLICTS_IDS: invalid_ids}
        )

    return response.Response()