import json
from rest_framework import status, permissions
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework.parsers import MultiPartParser, FormParser
from django.shortcuts import get_object_or_404
from .models import TeamMember, TeamMemberPortfolio, TeamMemberServiceRate


class IsVendor(permissions.BasePermission):
    def has_permission(self, request, view):
        return (
            request.user.is_authenticated and
            request.user.user_type == 'vendor' and
            hasattr(request.user, 'vendor_profile')
        )


def serialize_team_member(member, request=None):
    """Serialize a team member with nested service rates and portfolio images."""
    portfolio = []
    for img in member.portfolio_images.all():
        image_url = img.image.url if img.image else None
        if request and image_url:
            image_url = request.build_absolute_uri(image_url)
        portfolio.append({
            'id': img.id,
            'image': image_url,
            'created_at': img.created_at.isoformat(),
        })

    service_rates = []
    for rate in member.service_rates.select_related('service').all():
        service_rates.append({
            'id': rate.id,
            'service_id': rate.service_id,
            'service_name': rate.service.name,
            'service_price': str(rate.service.price) if rate.service.price else None,
            'rate': str(rate.rate),
            'commission_type': rate.commission_type,
            'commission_value': str(rate.commission_value),
        })

    photo_url = member.photo.url if member.photo else None
    if request and photo_url:
        photo_url = request.build_absolute_uri(photo_url)

    return {
        'id': member.id,
        'name': member.name,
        'email': member.email,
        'phone': member.phone,
        'bio': member.bio,
        'photo': photo_url,
        'display_on_public': member.display_on_public,
        'service_rates': service_rates,
        'portfolio_images': portfolio,
        'created_at': member.created_at.isoformat(),
        'updated_at': member.updated_at.isoformat(),
    }


def save_service_rates(member, service_rates_json):
    """Parse and save service rates for a team member (replace strategy)."""
    member.service_rates.all().delete()

    if not service_rates_json:
        return

    try:
        rates = json.loads(service_rates_json) if isinstance(service_rates_json, str) else service_rates_json
    except (json.JSONDecodeError, TypeError):
        return

    for rate_data in rates:
        service_id = rate_data.get('service_id')
        rate = rate_data.get('rate')
        if not service_id or not rate:
            continue
        TeamMemberServiceRate.objects.create(
            team_member=member,
            service_id=service_id,
            rate=rate,
            commission_type=rate_data.get('commission_type', 'percentage'),
            commission_value=rate_data.get('commission_value', 0),
        )


class VendorTeamListView(APIView):
    """List all team members (GET) or create a new team member (POST)."""
    permission_classes = [IsVendor]
    parser_classes = [MultiPartParser, FormParser]

    def get(self, request):
        members = TeamMember.objects.filter(
            vendor=request.user.vendor_profile
        ).prefetch_related('portfolio_images', 'service_rates', 'service_rates__service')

        data = [serialize_team_member(m, request) for m in members]
        return Response({'success': True, 'data': data})

    def post(self, request):
        name = request.data.get('name', '').strip()
        if not name:
            return Response(
                {'success': False, 'message': 'Name is required'},
                status=status.HTTP_400_BAD_REQUEST
            )

        member = TeamMember.objects.create(
            vendor=request.user.vendor_profile,
            name=name,
            email=request.data.get('email', '').strip() or None,
            phone=request.data.get('phone', '').strip() or None,
            bio=request.data.get('bio', ''),
            photo=request.FILES.get('photo'),
            display_on_public=request.data.get('display_on_public', 'true').lower() != 'false',
        )

        save_service_rates(member, request.data.get('service_rates'))

        # Handle portfolio images
        for f in request.FILES.getlist('portfolio'):
            if member.portfolio_images.count() >= 10:
                break
            if f.size > 200 * 1024:
                continue
            TeamMemberPortfolio.objects.create(team_member=member, image=f)

        data = serialize_team_member(member, request)
        return Response({'success': True, 'data': data}, status=status.HTTP_201_CREATED)


class VendorTeamDetailView(APIView):
    """Get, update, or delete a single team member."""
    permission_classes = [IsVendor]
    parser_classes = [MultiPartParser, FormParser]

    def _get_member(self, request, member_id):
        return get_object_or_404(
            TeamMember,
            id=member_id,
            vendor=request.user.vendor_profile
        )

    def get(self, request, member_id):
        member = self._get_member(request, member_id)
        data = serialize_team_member(member, request)
        return Response({'success': True, 'data': data})

    def put(self, request, member_id):
        member = self._get_member(request, member_id)

        member.name = request.data.get('name', member.name).strip() or member.name
        member.email = request.data.get('email', member.email) or None
        member.phone = request.data.get('phone', member.phone) or None
        member.bio = request.data.get('bio', member.bio)

        display = request.data.get('display_on_public')
        if display is not None:
            member.display_on_public = str(display).lower() != 'false'

        if 'photo' in request.FILES:
            member.photo = request.FILES['photo']

        member.save()

        if 'service_rates' in request.data:
            save_service_rates(member, request.data.get('service_rates'))

        data = serialize_team_member(member, request)
        return Response({'success': True, 'data': data})

    def delete(self, request, member_id):
        member = self._get_member(request, member_id)
        member.delete()
        return Response({'success': True, 'message': 'Team member deleted'})


class TeamMemberPortfolioView(APIView):
    """Upload portfolio images for a team member."""
    permission_classes = [IsVendor]
    parser_classes = [MultiPartParser, FormParser]

    def post(self, request, member_id):
        member = get_object_or_404(
            TeamMember,
            id=member_id,
            vendor=request.user.vendor_profile
        )

        files = request.FILES.getlist('images')
        if not files:
            return Response(
                {'success': False, 'message': 'No images provided'},
                status=status.HTTP_400_BAD_REQUEST
            )

        current_count = member.portfolio_images.count()
        uploaded = []

        for f in files:
            if current_count >= 10:
                break
            if f.size > 200 * 1024:
                continue
            img = TeamMemberPortfolio.objects.create(team_member=member, image=f)
            image_url = img.image.url
            if request:
                image_url = request.build_absolute_uri(image_url)
            uploaded.append({
                'id': img.id,
                'image': image_url,
                'created_at': img.created_at.isoformat(),
            })
            current_count += 1

        return Response({'success': True, 'data': uploaded}, status=status.HTTP_201_CREATED)


class TeamMemberPortfolioDeleteView(APIView):
    """Delete a single portfolio image."""
    permission_classes = [IsVendor]

    def delete(self, request, image_id):
        image = get_object_or_404(TeamMemberPortfolio, id=image_id)

        # Verify ownership
        if image.team_member.vendor != request.user.vendor_profile:
            return Response(
                {'success': False, 'message': 'Not authorized'},
                status=status.HTTP_403_FORBIDDEN
            )

        image.delete()
        return Response({'success': True, 'message': 'Image deleted'})


class PublicVendorTeamView(APIView):
    """Public endpoint to get a vendor's team members."""
    permission_classes = [permissions.AllowAny]

    def get(self, request, vendor_slug):
        from accounts.models import VendorProfile

        vendor = get_object_or_404(VendorProfile, slug=vendor_slug)
        members = TeamMember.objects.filter(
            vendor=vendor,
            display_on_public=True
        ).prefetch_related('portfolio_images', 'service_rates', 'service_rates__service')

        data = [serialize_team_member(m, request) for m in members]
        return Response({'success': True, 'data': data})
