from rest_framework import viewsets
from .models import ManualParserSelector
from .serializers import ManualParserSelectorSerializer

class ManualParserSelectorViewSet(viewsets.ReadOnlyModelViewSet):
    queryset = ManualParserSelector.objects.all().order_by("fieldtype")
    serializer_class = ManualParserSelectorSerializer
    # Możesz dodać permissiony lub rozbudować panel zarządzania



# manual_agregator/api/views.py

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status, permissions
from extractly.models import NetworkMonitoredPage, SourceManual
from manual_agregator.parser import parse_manual_data
from manual_agregator.run_parser import safe_json_loads, map_data_to_manual_model

class ManualParserTestView(APIView):
    permission_classes = [permissions.IsAuthenticated]  # lub Custom
    
    def post(self, request):
        html = request.data.get("html")
        parser_id = request.data.get("parser_id")
        page_id = request.data.get("page_id")
        limit = int(request.data.get("limit", 1))
        name = request.data.get("name")
        force = request.data.get("force", False)
        dry_run = request.data.get("dry_run", True)
        result = []

        # 1. Test surowego HTML z parserem
        if html and parser_id:
            try:
                parser = SourceManual.objects.get(id=parser_id)
                # Stwórz "wirtualny" NetworkMonitoredPage do testu
                page = NetworkMonitoredPage(html=html, source=parser.source)
                ok = parse_manual_data(page, strict=False)
                data = page.parse_data or safe_json_loads(page.raw_data or "{}")
                mapped = map_data_to_manual_model(data, page)
                result.append({
                    "input_id": None,
                    "url": None,
                    "parsed_data": data,
                    "mapped_to_model": mapped,
                    "stats": data.get("_stats", {})
                })
            except Exception as e:
                return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
            return Response({
                "result": result,
                "status": "success",
                "count": 1,
                "dry_run": True
            })

        # 2. Test istniejącej strony (po ID)
        elif page_id:
            try:
                page = NetworkMonitoredPage.objects.get(id=page_id)
                ok = parse_manual_data(page, strict=False)
                data = page.parse_data or safe_json_loads(page.raw_data or "{}")
                mapped = map_data_to_manual_model(data, page)
                result.append({
                    "input_id": page.id,
                    "url": page.url,
                    "parsed_data": data,
                    "mapped_to_model": mapped,
                    "stats": data.get("_stats", {})
                })
            except Exception as e:
                return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)
            return Response({
                "result": result,
                "status": "success",
                "count": 1,
                "dry_run": True
            })

        # 3. Test batch (limit, name, force)
        else:
            qs = NetworkMonitoredPage.objects.all() if force else NetworkMonitoredPage.objects.filter(is_complete=True, is_active=True, network_ad_manual__isnull=True)
            if name:
                qs = qs.filter(name__icontains=name)
            qs = qs[:limit]
            for page in qs:
                try:
                    parse_manual_data(page, strict=False)
                    data = page.parse_data or safe_json_loads(page.raw_data or "{}")
                    mapped = map_data_to_manual_model(data, page)
                    result.append({
                        "input_id": page.id,
                        "url": page.url,
                        "parsed_data": data,
                        "mapped_to_model": mapped,
                        "stats": data.get("_stats", {})
                    })
                except Exception as e:
                    result.append({
                        "input_id": page.id,
                        "url": page.url,
                        "error": str(e)
                    })
            return Response({
                "result": result,
                "status": "success",
                "count": len(result),
                "dry_run": dry_run
            })


from rest_framework import viewsets, permissions, filters
from django_filters.rest_framework import DjangoFilterBackend
from .models import ManualParserModels
from .serializers import ManualParserModelsSerializer
from .filters import ManualParserModelsFilter
from .pagination import ManualParserModelsPagination

class ManualParserModelsViewSet(viewsets.ModelViewSet):
    queryset = ManualParserModels.objects.all().order_by('id')
    serializer_class = ManualParserModelsSerializer
    permission_classes = [permissions.IsAuthenticated]  # lub zmień na AllowAny do testów
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = ManualParserModelsFilter
    search_fields = ["name", "label", "description"]
    ordering_fields = ["id", "name", "label"]
    pagination_class = ManualParserModelsPagination