from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated
from rest_framework.parsers import MultiPartParser
from django.utils.translation import gettext as _
from django.db.models import Q
from django.utils import timezone
from django.core.files.storage import default_storage
from django.http.response import HttpResponse, Http404
from django.urls import reverse

from pingcap_sso.api.base import Endpoint
from pingcap_sso.forms.partner import (
    PartnerCompatibilityCertificationApplicationForm,
)
from pingcap_sso.forms.phone import PhoneForm
from pingcap_sso.models import (
    SecurityCode,
    PartnerCompatibilityCertification,
)
from pingcap_sso.exceptions import RateLimitError
from pingcap_sso.utils.time import local_time_format
from pingcap_sso.utils.requests import get_client_ip


class PartnerCompatibilityCertificationListEndpoint(Endpoint):
    permission_classes = (IsAuthenticated, )

    def get(self, request, *args, **kwargs):
        try:
            cur_page = int(request.GET.get('currentPage', 1))
            per_page = int(request.GET.get('perPage', 10))
            search = request.GET.get('search', '')
        except Exception:
            return Response({
                'detail': _('wrong params')
            }, 400)
        qs = PartnerCompatibilityCertification.objects.filter(
            status=PartnerCompatibilityCertification.STATUS_APPROVED,
            cert_valid_to__gte=timezone.now(),
        ).order_by('-created_at')
        if search:
            qs = qs.filter(
                Q(cert_number=search) |
                Q(company__icontains=search) |
                Q(product_name__icontains=search) |
                Q(compatible_database_version_text__icontains=search)
            )
        total_num = qs.count()
        qs = qs[(cur_page - 1) * per_page:cur_page * per_page]
        data = [
            {
                'number': ap.cert_number,
                'company': ap.company,
                'product_name': ap.product_name,
                'compatible_database_version': ap.compatible_database_version_text,
                'solution_type': ap.solution_type_text,
                'status': ap.status,
                'status_display': ap.get_status_display(),
                'created_at': local_time_format(ap.created_at),
                'cert_valid_from': ap.cert_valid_from.strftime('%Y-%m-%d'),
                'cert_valid_to': ap.cert_valid_to.strftime('%Y-%m-%d'),
            }
            for ap in qs
        ]
        return Response({
            'detail': _('success'),
            'data': data,
            'total_num': total_num,
            'per_page': per_page,
            'cur_page': cur_page,
        })


class PartnerCompatibilityCertificationApplicationSmsCodeEndpoint(Endpoint):
    permission_classes = (IsAuthenticated, )

    def post(self, request, *args, **kwargs):
        form = PhoneForm(data=request.data)
        if not form.is_valid():
            return Response({
                'detail': _('params error'),
                'errors': form.errors
            }, status=400)

        try:
            SecurityCode.send_code(
                form.cleaned_data['phone'],
                channel=SecurityCode.DELIVER_BY_PHONE,
                scene=SecurityCode.SCENE_PARTNER_CERTIFICATION,
                user=request.user,
                ip=get_client_ip(request),
            )
        except RateLimitError:
            return Response({
                'detail': _('rate limit')
            }, status=429)
        else:
            return Response({
                'detail': _('success')
            })


class PartnerCompatibilityCertificationApplicationEndpoint(Endpoint):
    permission_classes = (IsAuthenticated, )
    parser_classes = (MultiPartParser, )

    def post(self, request, *args, **kwargs):
        form = PartnerCompatibilityCertificationApplicationForm(
            request, request.user, data=request.data, files=request.FILES
        )
        if not form.is_valid():
            return Response({
                'detail': _('params error'),
                'errors': form.errors
            }, status=400)

        form.save()
        return Response({
            'detail': _('success')
        })

    def get(self, request, *args, **kwargs):
        try:
            cur_page = int(request.GET.get('currentPage', 1))
            per_page = int(request.GET.get('perPage', 10))
        except Exception:
            return Response({
                'detail': _('wrong params')
            }, 400)

        qs = PartnerCompatibilityCertification.objects.filter(
            user=request.user
        ).order_by('-created_at')
        qs = qs[(cur_page - 1) * per_page:cur_page * per_page]
        total_num = qs.count()
        data = [
            {
                'number': ap.number,
                'company': ap.company,
                'product_name': ap.product_name,
                'status': ap.status,
                'status_display': ap.get_status_display(),
                'staff_comment': ap.staff_comment,
                'created_at': local_time_format(ap.created_at),
            }
            for ap in qs
        ]
        return Response({
            'detail': _('success'),
            'data': data,
            'total_num': total_num,
            'per_page': per_page,
            'cur_page': cur_page,
        })


class PartnerCompatibilityCertificationApplicationDetailEndpoint(Endpoint):
    permission_classes = (IsAuthenticated, )

    def get(self, request, application_number, *args, **kwargs):
        try:
            application = PartnerCompatibilityCertification.objects.get(
                number=application_number,
                user=request.user
            )
        except PartnerCompatibilityCertification.DoesNotExist:
            return Response({
                'detail': _('application not found')
            }, 404)

        return Response({
            'detail': _('success'),
            'data': {
                'number': application.number,
                'company': application.company,
                'company_address': application.company_address,
                'contact_name': application.contact_name,
                'contact_phone': application.contact_phone,
                'contact_email': application.contact_email,
                'contact_job_title': application.contact_job_title_code,
                'product_name': application.product_name,
                'product_description': application.product_description,
                'purpose_of_certification': application.purpose_of_certification,
                'shipping_address': application.shipping_address,
                'solution_type': application.solution_type_code,
                'product_industry': application.product_industry_code,
                'compatible_database_version': application.compatible_database_version_code,
                'infra_category': application.infra_category_code,
                'cert_owner_name': application.cert_owner_name,
                'cert_owner_job_title': application.cert_owner_job_title,
                'attachment_1': reverse(
                    'api:partner-compatibility-certification-application-attachment-1',
                    args=[application_number]
                ),
                'company_logo': reverse(
                    'api:partner-compatibility-certification-application-company-logo',
                    args=[application_number]
                ),
                'status': application.status,
                'staff_comment': application.staff_comment,
            }
        })


class PartnerCompatibilityCertificationApplicationAttachment1Endpoint(Endpoint):
    permission_classes = (IsAuthenticated, )

    def get(self, request, application_number, *args, **kwargs):
        try:
            application = PartnerCompatibilityCertification.objects.get(
                number=application_number,
                user=request.user
            )
        except PartnerCompatibilityCertification.DoesNotExist:
            return Response({
                'detail': _('application not found')
            }, 404)
    
        if not application.attachment_1:
            raise Http404

        try:
            _file = default_storage.open(application.attachment_1.path)
            return HttpResponse(_file, content_type=application.attachment_1.extension)
        except Exception:
            raise Http404


class PartnerCompatibilityCertificationApplicationCompanyLogoEndpoint(Endpoint):
    permission_classes = (IsAuthenticated, )

    def get(self, request, application_number, *args, **kwargs):
        try:
            application = PartnerCompatibilityCertification.objects.get(
                number=application_number,
                user=request.user
            )
        except PartnerCompatibilityCertification.DoesNotExist:
            return Response({
                'detail': _('application not found')
            }, 404)

        if not application.company_logo:
            raise Http404

        try:
            _file = default_storage.open(application.company_logo.path)
            return HttpResponse(_file, content_type=application.company_logo.extension)
        except Exception:
            raise Http404