from typing import TYPE_CHECKING, Union

from rules import predicate, always_deny, always_allow

from outbo.apps.projects.rules import can_read_project

if TYPE_CHECKING:
    from outbo.apps.authentication.models import User
    from outbo.apps.products.models import (
        Product,
        Brief,
        Draft,
        FirstFinal,
        PrintingFiles,
    )


# Product
@predicate
def _has_readable_project(user: "User", product: "Product"):
    return can_read_project.test(user, product.project)


# CRUD
can_create_product = always_deny
can_read_product = _has_readable_project
can_update_product = always_deny
can_delete_product = always_deny

# Shared
@predicate
def _has_readable_product(user: "User", obj: Union["Brief", "Draft"]):
    return can_read_product.test(user, obj.product)


# Brief
@predicate
def can_publish_brief(user: "User", brief: "Brief"):
    return brief.publishable_for_user(user=user)


@predicate
def can_edit_brief(user: "User", brief: "Brief"):
    return brief.editable_for_user(user=user)


@predicate
def can_accept_brief(user: "User", brief: "Brief"):
    return brief.acceptable_for_user(user=user)


# CRUD
can_create_brief = always_deny
can_read_brief = _has_readable_product
can_update_brief = can_edit_brief | can_accept_brief
can_delete_brief = always_deny


@predicate
def _has_editable_brief(user, photo_or_blanking):
    return can_edit_brief.test(user, photo_or_blanking.brief)


# Brief files:
can_delete_photo = _has_editable_brief
can_delete_blanking = _has_editable_brief


# Draft
@predicate
def can_edit_draft(user: "User", draft: "Draft"):
    return draft.editable_for_user(user=user)


@predicate
def can_accept_draft(user: "User", draft: "Draft"):
    return draft.acceptable_for_user(user=user)


# CRUD
can_create_draft = always_deny
can_read_draft = _has_readable_product
can_update_draft = can_edit_draft | can_accept_draft
can_delete_draft = always_deny

# Draft Files


# CRUD
can_create_draft_file = always_allow
can_read_draft_file = always_allow
can_update_draft_file = always_deny
can_delete_draft_file = always_deny

# FF
@predicate
def can_edit_ff(user: "User", ff: "FirstFinal"):
    return ff.editable_for_user(user=user)


@predicate
def can_accept_ff(user: "User", ff: "FirstFinal"):
    return ff.acceptable_for_user(user=user)


# CRUD
can_create_ff = always_deny
can_read_ff = _has_readable_product
can_update_ff = can_edit_ff | can_accept_ff
can_delete_ff = always_deny

# Draft Files


# CRUD
can_create_ff_file = always_allow
can_read_ff_file = always_allow
can_update_ff_file = always_deny
can_delete_ff_file = always_deny


# PF
@predicate
def can_edit_pf(user: "User", pf: "PrintingFiles"):
    return pf.editable_for_user(user=user)


@predicate
def can_accept_pf(user: "User", pf: "PrintingFiles"):
    return pf.acceptable_for_user(user=user)


# CRUD
can_create_pf = always_deny
can_read_pf = _has_readable_product
can_update_pf = can_edit_pf | can_accept_pf
can_delete_pf = always_deny

# Draft Files


# CRUD
can_create_pf_file = always_allow
can_read_pf_file = always_allow
can_update_pf_file = always_deny
can_delete_pf_file = always_deny