from rest_framework import status, viewsets
from rest_framework.decorators import action
from rest_framework.response import Response

from apps.accounts.permissions import CanRegisterActiveSite, IsExecutive, can_sync
from apps.accounts.scoping import filter_active_sites_queryset
from apps.farms.services.active_site_registry import ensure_hq_site_for_active_site
from apps.sync.models import ActiveSite
from apps.sync.serializers import ActiveSiteSerializer, ActiveSiteWriteSerializer


class ActiveSiteViewSet(viewsets.ModelViewSet):
    """
    List/read: scoped (director all; BUH managed GMs; GM own).
    Create/update/delete: GM and GM Admin.
    Sync: GM and GM Admin only (stubs until mirror pull is implemented).

    Creating an active site also attaches (or creates) an HQ Site so farm data
    appears in the executive view list.
    """

    executive_sync_action = True

    def get_queryset(self):
        qs = ActiveSite.objects.select_related("registered_by").all()
        return filter_active_sites_queryset(qs, self.request.user)

    def get_permissions(self):
        if self.action in {"create", "update", "partial_update", "destroy"}:
            return [CanRegisterActiveSite()]
        return [IsExecutive()]

    def get_serializer_class(self):
        if self.action in {"create", "update", "partial_update"}:
            return ActiveSiteWriteSerializer
        return ActiveSiteSerializer

    def perform_create(self, serializer):
        active_site = serializer.save(registered_by=self.request.user)
        ensure_hq_site_for_active_site(active_site)

    def perform_update(self, serializer):
        active_site = serializer.save()
        if active_site.is_active:
            ensure_hq_site_for_active_site(active_site)

    @action(detail=True, methods=["post"], url_path="sync")
    def sync(self, request, pk=None):
        if not can_sync(request.user):
            return Response({"detail": "Sync not allowed."}, status=status.HTTP_403_FORBIDDEN)
        active_site = self.get_object()
        if not active_site.is_active:
            return Response(
                {"detail": "Active site is inactive."},
                status=status.HTTP_400_BAD_REQUEST,
            )
        return Response(
            {
                "detail": "Active site sync not implemented yet.",
                "active_site": ActiveSiteSerializer(active_site).data,
            },
            status=status.HTTP_501_NOT_IMPLEMENTED,
        )

    @action(detail=False, methods=["post"], url_path="sync-all")
    def sync_all(self, request):
        if not can_sync(request.user):
            return Response({"detail": "Sync not allowed."}, status=status.HTTP_403_FORBIDDEN)
        sites = list(self.get_queryset().filter(is_active=True))
        return Response(
            {
                "detail": "Active site sync-all not implemented yet.",
                "active_site_count": len(sites),
                "active_sites": ActiveSiteSerializer(sites, many=True).data,
            },
            status=status.HTTP_501_NOT_IMPLEMENTED,
        )