"""Logic for Canned Responses."""

from owsresponse import response

from product_review.models import canned_response as canned_response_model
from product_review.models import (
    canned_response_category as canned_response_category_model)
from product_review.models import canned_response_note as canned_response_note_model
from product_review.util.db import db_transaction


def get_canned_response(canned_response_id, language_code=None):
    """Return a canned response item."""
    result = canned_response_model.get_canned_response_item(
        canned_response_id, language_code=language_code
    )
    return response.Response(result)


def _format_canned_response_items(results, total_records, offset, limit):
    """Format canned response items."""
    if not results:
        output_results = []
    else:
        output_results = [r.to_dict() for r in results]
    return {
        "items": output_results,
        "pagination": {
            "type": "standard",
            "offset": int(offset or 0),
            "limit": len(output_results),
            "total_records": total_records,
        },
    }


def get_canned_response_items(
    category_id=None,
    modified_by_user_id=None,
    review_context=None,
    language_code=None,
    page_limit=None,
    page_offset=None,
):
    """Return list of canned response items."""
    results, total_records = canned_response_model.get_items(
        category_id=category_id,
        modified_by_user_id=modified_by_user_id,
        review_context=review_context,
        language_code=language_code,
        page_limit=page_limit,
        page_offset=page_offset,
    )
    response_msg = _format_canned_response_items(
        results, total_records, page_offset, page_limit
    )
    return response.Response(response_msg)


def get_canned_response_categories():
    """Get list of canned response categories."""
    return response.Response(canned_response_category_model.get_items())


def soft_delete_canned_response(canned_response_id, modified_by_user_id):
    """Mark a canned response item for deletion."""
    with db_transaction:
        updated_canned_response_item = canned_response_model.update_canned_response(
            canned_response_id, modified_by_user_id, for_deletion=True
        )
    return updated_canned_response_item


def dataload_canned_response_notes(keys):
    """Dataload canned response notes."""
    mapped_keys = [[x["canned_response_id"], x["language_code"]] for x in keys]
    canned_response_notes = canned_response_note_model.get_canned_response_notes(
        mapped_keys
    )
    mapped_response = {
        f"{entry.language_code}-{entry.canned_response_id}": entry.to_dict()
        for entry in canned_response_notes
    }
    return [
        mapped_response.get(f"{language_code}-{canned_response_id}")
        for canned_response_id, language_code in mapped_keys
    ]