from django.shortcuts import render
from rest_framework import viewsets, permissions, status, filters
from rest_framework.response import Response
from rest_framework.decorators import action
from django_filters.rest_framework import DjangoFilterBackend
from .models import Template, TemplateCategory
from .serializers import (
    TemplateListSerializer, 
    TemplateDetailSerializer, 
    TemplateCreateUpdateSerializer,
    TemplateCategorySerializer
)
from .filters import TemplateFilter
from .utils import ApiResponse
from .pagination import StandardResultsSetPagination

# Create your views here.

class TemplateCategoryViewSet(viewsets.ModelViewSet):
    """
    模板分类视图集
    
    提供模板分类的增删改查功能
    """
    queryset = TemplateCategory.objects.all()
    serializer_class = TemplateCategorySerializer
    permission_classes = [permissions.AllowAny]  # 允许所有人访问
    pagination_class = StandardResultsSetPagination
    
    def list(self, request, *args, **kwargs):
        """获取所有模板分类"""
        queryset = self.filter_queryset(self.get_queryset())
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板分类列表成功"
        )
    
    def retrieve(self, request, *args, **kwargs):
        """获取单个模板分类详情"""
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板分类详情成功"
        )
    
    def create(self, request, *args, **kwargs):
        """创建模板分类"""
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            self.perform_create(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板分类创建成功",
                code=status.HTTP_201_CREATED
            )
        return ApiResponse.error(
            message="模板分类创建失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def update(self, request, *args, **kwargs):
        """更新模板分类"""
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        if serializer.is_valid():
            self.perform_update(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板分类更新成功"
            )
        return ApiResponse.error(
            message="模板分类更新失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def destroy(self, request, *args, **kwargs):
        """删除模板分类"""
        instance = self.get_object()
        self.perform_destroy(instance)
        return ApiResponse.success(
            data=None,
            message="模板分类删除成功"
        )
    
class TemplateViewSet(viewsets.ModelViewSet):
    """
    模板视图集
    
    提供模板的增删改查功能
    """
    queryset = Template.objects.all()
    permission_classes = [permissions.AllowAny]  # 允许所有人访问
    filter_backends = [DjangoFilterBackend, filters.SearchFilter, filters.OrderingFilter]
    filterset_class = TemplateFilter
    search_fields = ['title', 'content']
    ordering_fields = ['created_at', 'updated_at', 'title']
    ordering = ['-created_at']
    pagination_class = StandardResultsSetPagination
    
    def get_queryset(self):
        """
        自定义查询集，返回所有模板
        """
        return Template.objects.all()
    
    def get_serializer_class(self):
        """根据不同的操作返回不同的序列化器"""
        if self.action == 'list':
            return TemplateListSerializer
        elif self.action in ['create', 'update', 'partial_update']:
            return TemplateCreateUpdateSerializer
        return TemplateDetailSerializer
    
    def list(self, request, *args, **kwargs):
        """获取所有模板"""
        queryset = self.filter_queryset(self.get_queryset())
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板列表成功"
        )
    
    def retrieve(self, request, *args, **kwargs):
        """获取单个模板详情"""
        instance = self.get_object()
        serializer = self.get_serializer(instance)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板详情成功"
        )
    
    def create(self, request, *args, **kwargs):
        """创建模板"""
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            self.perform_create(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板创建成功",
                code=status.HTTP_201_CREATED
            )
        return ApiResponse.error(
            message="模板创建失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def update(self, request, *args, **kwargs):
        """更新模板"""
        partial = kwargs.pop('partial', False)
        instance = self.get_object()
        serializer = self.get_serializer(instance, data=request.data, partial=partial)
        if serializer.is_valid():
            self.perform_update(serializer)
            return ApiResponse.success(
                data=serializer.data,
                message="模板更新成功"
            )
        return ApiResponse.error(
            message="模板更新失败",
            data=serializer.errors,
            code=status.HTTP_400_BAD_REQUEST
        )
    
    def destroy(self, request, *args, **kwargs):
        """删除模板"""
        instance = self.get_object()
        self.perform_destroy(instance)
        return ApiResponse.success(
            data=None,
            message="模板删除成功"
        )
    
    @action(detail=False, methods=['get'])
    def mine(self, request):
        """获取所有模板"""
        templates = Template.objects.all()
        page = self.paginate_queryset(templates)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(templates, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def public(self, request):
        """获取所有公开的模板"""
        templates = Template.objects.filter(is_public=True)
        page = self.paginate_queryset(templates)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(templates, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="获取公开模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_mission(self, request):
        """按任务类型获取模板"""
        mission = request.query_params.get('mission', None)
        if not mission:
            return ApiResponse.error(
                message="需要提供mission参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(mission=mission)
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="按任务类型获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_platform(self, request):
        """按平台获取模板"""
        platform = request.query_params.get('platform', None)
        if not platform:
            return ApiResponse.error(
                message="需要提供platform参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(platform=platform)
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="按平台获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_collaboration(self, request):
        """按合作模式获取模板"""
        collaboration_type = request.query_params.get('collaboration_type', None)
        if not collaboration_type:
            return ApiResponse.error(
                message="需要提供collaboration_type参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(collaboration_type=collaboration_type)
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="按合作模式获取模板成功"
        )
        
    @action(detail=False, methods=['get'])
    def by_service(self, request):
        """按服务类型获取模板"""
        service = request.query_params.get('service', None)
        if not service:
            return ApiResponse.error(
                message="需要提供service参数",
                code=status.HTTP_400_BAD_REQUEST
            )
            
        queryset = self.get_queryset().filter(service=service)
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return ApiResponse.success(
            data=serializer.data,
            message="按服务类型获取模板成功"
        )