"""Rejection Model."""

from product_review import models
from product_review.api import db
from product_review.util.db import db_transaction

STATUS_TYPES = [
    "orchard_processing",
    "label_confirmation",
    "transfer_to_content",
    "label_processing",
    "in_content",
]


class Release(db.Model):
    """Release Model.

    Represents Release metadata
    """

    __bind_key__ = "art_relations"
    __tablename__ = "releases"

    ingestion_completed = db.Column(db.DateTime)
    release_id = db.Column(
        db.Integer, primary_key=True, autoincrement=True, nullable=False
    )
    format = db.Column(db.String, default=None)  # noqa: A003
    release_status = db.Column(db.Enum(*STATUS_TYPES), default="orchard_processing")
    distribution_format_id = db.Column(db.Integer)
    product_type_id = db.Column(db.Integer)

    def to_dict(self):
        """Format release as dict."""
        return {
            "release_id": self.release_id,
            "release_status": self.release_status,
            "distribution_format_id": self.distribution_format_id,
            "format": self.format,
            "product_type_id": self.product_type_id,
        }


class ReleaseApprovalQueue(db.Model):
    """Model for release approval queue."""

    __bind_key__ = "art_relations"
    __tablename__ = "release_approval_queue"

    release_approval_id = db.Column(
        db.Integer, primary_key=True, autoincrement=True, nullable=False
    )
    release_id = db.Column(db.Integer, nullable=False)


class ReleaseStatus(db.Model):
    """Release Status Model.

    Represents ReleaseStatus metadata
    """

    __bind_key__ = "art_relations"
    __tablename__ = "release_status"

    release_status_id = db.Column(
        db.Integer, primary_key=True, autoincrement=True, nullable=False
    )
    release_id = db.Column(db.Integer, nullable=False)
    status = db.Column(
        db.Enum(*STATUS_TYPES), nullable=False, default="orchard_processing"
    )


def reset_product(product_id):
    """Reset product in art_relations."""
    release = Release.query.get(product_id)
    release.release_status = "transfer_to_content"
    release.ingestion_completed = None

    ReleaseApprovalQueue.query.filter(
        ReleaseApprovalQueue.release_id == product_id
    ).delete()

    ReleaseStatus.query.filter(
        ReleaseStatus.release_id == product_id, ReleaseStatus.status == "in_content"
    ).delete()


def get_products(product_ids):
    """Get list of products defined by ids."""
    results = Release.query.filter(Release.release_id.in_(product_ids)).all()
    return results


@db_transaction
def sync_db():
    """Sync review_queue item statuses with art_relations."""
    _sync_db()


def _sync_db():
    """Sync DB logic."""
    # mysql doesn't support "infinite" limit so any reasonably large number will do
    existing_items, _ = models.review_queue.get_items(page_limit=10000)
    # filter out test products
    existing_items = [item for item in existing_items if item.review_queue_id > 7]
    ar_items = get_products([item.product_id for item in existing_items])
    ar_dict = {item.release_id: item.to_dict() for item in ar_items}
    to_delete, _ = _build_lists(existing_items, ar_dict)
    _save_changes(to_delete)


@db_transaction
def _save_changes(to_delete):
    """Delete review queue items."""
    for d in to_delete:
        models.score_history.delete(d)
        models.unsubmit.delete(d)
        models.approval.delete(d)
        models.rejection.delete(d)
        models.review_validation_history.delete(d)
        models.queue_move_history.delete(d)
        models.canned_response_history.delete(d)
        models.review_queue.delete(d)


def _build_lists(existing_items, ar_dict):
    """Build lists of review queue items to delete/reset."""
    to_delete = []
    to_reset = []
    found_product_ids = []

    for item in existing_items:
        if item.product_id not in ar_dict:
            to_delete.append(item.review_queue_id)
            continue

        ar_release = ar_dict[item.product_id]
        if item.status == "new":
            # delete duplicates of "new" product ids in the queue
            if item.product_id in found_product_ids:
                to_delete.append(item.review_queue_id)
                continue

            found_product_ids.append(item.product_id)
            # delete "new" items that don't have a proper status in AR
            if (
                ar_release["release_status"] != "transfer_to_content"
                or ar_release["distribution_format_id"] != 1
                or ar_release["format"] not in {"Full Length", "Single", "EP"}
                or ar_release["product_type_id"] != 1
            ):
                to_delete.append(item.review_queue_id)
                continue

        # reset some "completed" items back to "new" based on AR status
        elif item.status == "complete":
            if (
                ar_release["release_status"] == "transfer_to_content"
                and ar_release["distribution_format_id"] == 1
            ):
                to_reset.append(item.review_queue_id)
                continue
    return to_delete, to_reset