from __future__ import annotations

from typing import Any

from .plan_items import (
    RemediationCoverageGap,
    build_artifact_requirements,
    build_plan_from_finding,
    build_required_inputs,
)
from .plan_tasks import (
    build_gap_item,
    build_plan_message,
    build_readiness_summary,
    build_remediation_tasks,
    derive_coverage_blocking_reasons,
)


class ServiceDelegatesMixin:
    """Delegation methods connecting to plan builders."""

    def _build_plan_from_finding(self, **kwargs: Any):
        return build_plan_from_finding(self, **kwargs)

    def _build_required_inputs(
        self, *, session: dict[str, Any], finding: dict[str, Any]
    ):
        return build_required_inputs(finding=finding)

    def _build_artifact_requirements(
        self,
        *,
        session: dict[str, Any],
        finding: dict[str, Any],
        destination_folder: str,
    ):
        return build_artifact_requirements(
            finding=finding, destination_folder=destination_folder
        )

    def _build_remediation_tasks(self, **kwargs: Any):
        return build_remediation_tasks(self, **kwargs)

    def _build_readiness_summary(self, **kwargs: Any):
        return build_readiness_summary(self, **kwargs)

    def _build_plan_message(self, *, document_type: str, readiness_summary: Any) -> str:
        return build_plan_message(
            document_type=document_type, readiness_summary=readiness_summary
        )

    def _build_gap_item(self, plan: Any):
        return build_gap_item(self, plan)

    def _derive_coverage_blocking_reasons(
        self,
        *,
        project_code: str,
        document_type: str,
        coverage_project: dict[str, Any] | None,
    ) -> list[RemediationCoverageGap]:
        return derive_coverage_blocking_reasons(
            project_code=project_code,
            document_type=document_type,
            coverage_project=coverage_project,
        )