"""
Plugin Distribution System Views

API endpoints for plugin distribution, updates, and management.
"""
import logging
from django.http import FileResponse, Http404
from django.shortcuts import get_object_or_404
from django.utils import timezone
from rest_framework import status
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import AllowAny, IsAuthenticated, IsAdminUser
from rest_framework.response import Response
from rest_framework.views import APIView

from .models import Plugin, PluginVersion, PluginInstallation, PluginDownload
from .serializers import (
    PluginSerializer,
    PluginDetailSerializer,
    PluginVersionSerializer,
    PluginInfoSerializer,
    CheckUpdateSerializer,
    RegisterInstallationSerializer,
    HealthCheckSerializer,
    PluginInstallationSerializer,
    AdminPluginVersionCreateSerializer,
    AdminPluginVersionUploadSerializer,
)
from .utils import get_plugin_file_path, parse_version_to_code

logger = logging.getLogger(__name__)


# ============================================================================
# Public Endpoints (No Auth Required)
# ============================================================================

@api_view(['GET'])
@permission_classes([AllowAny])
def download_plugin(request, slug):
    """
    Download the latest version of a plugin.
    
    GET /api/plugins/{slug}/download/
    
    Returns the ZIP file for the latest released version.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    latest = plugin.get_latest_version()
    
    if not latest:
        return Response(
            {'error': 'No version available for download'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    file_path = get_plugin_file_path(plugin.platform, latest.file_path)
    
    if not file_path or not file_path.exists():
        logger.error(f"Plugin file not found: {latest.file_path}")
        return Response(
            {'error': 'Plugin file not found'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    # Track download
    PluginDownload.objects.create(
        plugin=plugin,
        version=latest,
        ip_address=get_client_ip(request),
        user_agent=request.META.get('HTTP_USER_AGENT', '')[:500],
        download_type='manual',
    )
    
    response = FileResponse(
        open(file_path, 'rb'),
        content_type='application/zip'
    )
    response['Content-Disposition'] = f'attachment; filename="{latest.file_path}"'
    response['Content-Length'] = latest.file_size
    return response


@api_view(['GET'])
@permission_classes([AllowAny])
def check_update(request, slug):
    """
    Check if an update is available for a plugin.
    
    GET /api/plugins/{slug}/check-update/?current_version=1.0.0
    
    Called by installed plugins to check for updates.
    Returns update availability and download URL if available.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    current_version = request.query_params.get('current_version', '0.0.0')
    current_code = parse_version_to_code(current_version)
    
    latest = plugin.get_latest_version()
    
    if not latest:
        return Response({
            'update_available': False,
            'current_version': current_version,
            'latest_version': None,
            'latest_version_code': None,
            'download_url': None,
            'changelog': None,
            'info_url': None,
            'force_update': False,
            'checksum': None,
        })
    
    update_available = latest.version_code > current_code
    
    # Build download URL
    download_url = None
    if update_available:
        download_url = request.build_absolute_uri(f'/api/plugins/{slug}/download/')
    
    response_data = {
        'update_available': update_available,
        'current_version': current_version,
        'latest_version': latest.version if update_available else None,
        'latest_version_code': latest.version_code if update_available else None,
        'download_url': download_url,
        'changelog': latest.changelog if update_available else None,
        'info_url': request.build_absolute_uri(f'/api/plugins/{slug}/info/'),
        'force_update': latest.force_update if update_available else False,
        'checksum': latest.checksum if update_available else None,
    }
    
    serializer = CheckUpdateSerializer(response_data)
    return Response(serializer.data)


@api_view(['GET'])
@permission_classes([AllowAny])
def plugin_info(request, slug):
    """
    Get plugin information in WordPress-compatible format.
    
    GET /api/plugins/{slug}/info/
    
    Returns detailed plugin information for WordPress plugin info modal.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    latest = plugin.get_latest_version()
    
    if not latest:
        return Response(
            {'error': 'No version available'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    info_data = {
        'name': plugin.name,
        'slug': plugin.slug,
        'version': latest.version,
        'author': 'IGNY8',
        'homepage': plugin.homepage_url or 'https://igny8.com',
        'description': plugin.description,
        'changelog': latest.changelog,
        'download_url': request.build_absolute_uri(f'/api/plugins/{slug}/download/'),
        'file_size': latest.file_size,
        'requires_php': latest.min_php_version,
        'tested_wp': '6.7',
    }
    
    serializer = PluginInfoSerializer(info_data)
    return Response(serializer.data)


@api_view(['GET'])
@permission_classes([AllowAny])
def get_latest_plugin(request, platform):
    """
    Get the latest plugin for a platform.
    
    GET /api/plugins/{platform}/latest/
    
    Returns plugin info and download URL for the specified platform.
    """
    valid_platforms = ['wordpress', 'shopify', 'custom']
    if platform not in valid_platforms:
        return Response(
            {'error': f'Invalid platform. Must be one of: {valid_platforms}'},
            status=status.HTTP_400_BAD_REQUEST
        )
    
    plugin = Plugin.objects.filter(platform=platform, is_active=True).first()
    
    if not plugin:
        return Response(
            {'error': f'No plugin available for platform: {platform}'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    latest = plugin.get_latest_version()
    
    if not latest:
        return Response(
            {'error': 'No version available'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    return Response({
        'name': plugin.name,
        'slug': plugin.slug,
        'version': latest.version,
        'download_url': request.build_absolute_uri(f'/api/plugins/{plugin.slug}/download/'),
        'file_size': latest.file_size,
        'platform': plugin.platform,
        'description': plugin.description,
        'changelog': latest.changelog,
        'released_at': latest.released_at,
    })


# ============================================================================
# Authenticated Endpoints
# ============================================================================

@api_view(['POST'])
@permission_classes([IsAuthenticated])
def register_installation(request, slug):
    """
    Register a plugin installation on a site.
    
    POST /api/plugins/{slug}/register-installation/
    Body: { "site_id": 123, "version": "1.0.0" }
    
    Called after plugin is activated on a site.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    serializer = RegisterInstallationSerializer(data=request.data)
    
    if not serializer.is_valid():
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
    from igny8_core.auth.models import Site
    site_id = serializer.validated_data['site_id']
    version_str = serializer.validated_data['version']
    
    # Verify site belongs to user's account
    site = get_object_or_404(Site, id=site_id)
    
    if hasattr(request, 'account') and site.account_id != request.account.id:
        return Response(
            {'error': 'Site does not belong to your account'},
            status=status.HTTP_403_FORBIDDEN
        )
    
    # Find version record
    try:
        version = PluginVersion.objects.get(plugin=plugin, version=version_str)
    except PluginVersion.DoesNotExist:
        version = None
    
    # Create or update installation record
    installation, created = PluginInstallation.objects.update_or_create(
        site=site,
        plugin=plugin,
        defaults={
            'current_version': version,
            'is_active': True,
            'last_health_check': timezone.now(),
            'health_status': 'healthy',
        }
    )
    
    action = 'registered' if created else 'updated'
    logger.info(f"Plugin installation {action}: {plugin.name} v{version_str} on site {site.name}")
    
    return Response({
        'success': True,
        'message': f'Installation {action} successfully',
        'installation_id': installation.id,
    })


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def health_check(request, slug):
    """
    Report plugin health status.
    
    POST /api/plugins/{slug}/health-check/
    Body: { "site_id": 123, "version": "1.0.0", "status": "active" }
    
    Called periodically by installed plugins to report status.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    serializer = HealthCheckSerializer(data=request.data)
    
    if not serializer.is_valid():
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
    from igny8_core.auth.models import Site
    site_id = serializer.validated_data['site_id']
    version_str = serializer.validated_data['version']
    plugin_status = serializer.validated_data['status']
    
    site = get_object_or_404(Site, id=site_id)
    
    try:
        installation = PluginInstallation.objects.get(site=site, plugin=plugin)
    except PluginInstallation.DoesNotExist:
        # Auto-register if not exists
        try:
            version = PluginVersion.objects.get(plugin=plugin, version=version_str)
        except PluginVersion.DoesNotExist:
            version = None
        
        installation = PluginInstallation.objects.create(
            site=site,
            plugin=plugin,
            current_version=version,
            is_active=plugin_status == 'active',
        )
    
    # Update installation status
    installation.last_health_check = timezone.now()
    installation.is_active = plugin_status == 'active'
    
    if plugin_status == 'error':
        installation.health_status = 'error'
    else:
        installation.update_health_status()
    
    installation.save()
    
    # Check if update is available
    update_available = installation.check_for_update()
    
    return Response({
        'success': True,
        'health_status': installation.health_status,
        'update_available': update_available is not None,
        'latest_version': update_available.version if update_available else None,
    })


@api_view(['POST'])
@permission_classes([IsAuthenticated])
def track_download(request, slug):
    """
    Track a plugin download for analytics.
    
    POST /api/plugins/{slug}/track-download/
    
    Called before redirecting to download URL.
    """
    plugin = get_object_or_404(Plugin, slug=slug, is_active=True)
    latest = plugin.get_latest_version()
    
    if not latest:
        return Response(
            {'error': 'No version available'},
            status=status.HTTP_404_NOT_FOUND
        )
    
    # Get site if provided
    site = None
    site_id = request.data.get('site_id')
    if site_id:
        from igny8_core.auth.models import Site
        try:
            site = Site.objects.get(id=site_id)
        except Site.DoesNotExist:
            pass
    
    # Get account from request
    account = getattr(request, 'account', None)
    
    # Track download
    PluginDownload.objects.create(
        plugin=plugin,
        version=latest,
        site=site,
        account=account,
        ip_address=get_client_ip(request),
        user_agent=request.META.get('HTTP_USER_AGENT', '')[:500],
        download_type='manual',
    )
    
    return Response({
        'success': True,
        'download_url': request.build_absolute_uri(f'/api/plugins/{slug}/download/'),
    })


# ============================================================================
# Admin Endpoints
# ============================================================================

class AdminPluginListView(APIView):
    """List all plugins and their versions (admin)."""
    permission_classes = [IsAdminUser]
    
    def get(self, request):
        plugins = Plugin.objects.prefetch_related('versions').all()
        serializer = PluginDetailSerializer(plugins, many=True)
        return Response(serializer.data)
    
    def post(self, request):
        """Create a new plugin."""
        serializer = PluginSerializer(data=request.data)
        if serializer.is_valid():
            plugin = serializer.save()
            return Response(
                PluginSerializer(plugin).data,
                status=status.HTTP_201_CREATED
            )
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class AdminPluginVersionsView(APIView):
    """Manage plugin versions (admin)."""
    permission_classes = [IsAdminUser]
    
    def get(self, request, slug):
        """List all versions for a plugin."""
        plugin = get_object_or_404(Plugin, slug=slug)
        versions = plugin.versions.all()
        serializer = PluginVersionSerializer(versions, many=True)
        return Response(serializer.data)
    
    def post(self, request, slug):
        """Create a new version for a plugin."""
        plugin = get_object_or_404(Plugin, slug=slug)
        serializer = AdminPluginVersionCreateSerializer(data=request.data)
        
        if serializer.is_valid():
            # Check if version already exists
            version_str = serializer.validated_data['version']
            if PluginVersion.objects.filter(plugin=plugin, version=version_str).exists():
                return Response(
                    {'error': f'Version {version_str} already exists'},
                    status=status.HTTP_400_BAD_REQUEST
                )
            
            version = serializer.save(plugin=plugin)
            return Response(
                PluginVersionSerializer(version).data,
                status=status.HTTP_201_CREATED
            )
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)


class AdminPluginVersionDetailView(APIView):
    """Manage a specific plugin version (admin)."""
    permission_classes = [IsAdminUser]
    
    def get(self, request, slug, version):
        """Get version details."""
        plugin = get_object_or_404(Plugin, slug=slug)
        version_obj = get_object_or_404(PluginVersion, plugin=plugin, version=version)
        serializer = PluginVersionSerializer(version_obj)
        return Response(serializer.data)
    
    def patch(self, request, slug, version):
        """Update version details."""
        plugin = get_object_or_404(Plugin, slug=slug)
        version_obj = get_object_or_404(PluginVersion, plugin=plugin, version=version)
        
        serializer = PluginVersionSerializer(version_obj, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
    
    def delete(self, request, slug, version):
        """Delete a version (only drafts)."""
        plugin = get_object_or_404(Plugin, slug=slug)
        version_obj = get_object_or_404(PluginVersion, plugin=plugin, version=version)
        
        if version_obj.status not in ['draft', 'testing']:
            return Response(
                {'error': 'Can only delete draft or testing versions'},
                status=status.HTTP_400_BAD_REQUEST
            )
        
        version_obj.delete()
        return Response(status=status.HTTP_204_NO_CONTENT)


@api_view(['POST'])
@permission_classes([IsAdminUser])
def admin_release_version(request, slug, version):
    """
    Release a plugin version.
    
    POST /api/admin/plugins/{slug}/versions/{version}/release/
    
    Makes the version available for download.
    """
    plugin = get_object_or_404(Plugin, slug=slug)
    version_obj = get_object_or_404(PluginVersion, plugin=plugin, version=version)
    
    if version_obj.status in ['released', 'update_ready']:
        return Response(
            {'error': 'Version is already released'},
            status=status.HTTP_400_BAD_REQUEST
        )
    
    if not version_obj.file_path:
        return Response(
            {'error': 'No file uploaded for this version'},
            status=status.HTTP_400_BAD_REQUEST
        )
    
    version_obj.release()
    
    logger.info(f"Released plugin version: {plugin.name} v{version}")
    
    return Response({
        'success': True,
        'message': f'Version {version} released successfully',
        'released_at': version_obj.released_at,
    })


@api_view(['POST'])
@permission_classes([IsAdminUser])
def admin_push_update(request, slug, version):
    """
    Push update to all installed sites.
    
    POST /api/admin/plugins/{slug}/versions/{version}/push-update/
    
    Sets status to 'update_ready' and notifies installations.
    """
    plugin = get_object_or_404(Plugin, slug=slug)
    version_obj = get_object_or_404(PluginVersion, plugin=plugin, version=version)
    
    if version_obj.status not in ['released', 'update_ready']:
        return Response(
            {'error': 'Version must be released before pushing update'},
            status=status.HTTP_400_BAD_REQUEST
        )
    
    # Mark as update ready
    version_obj.status = 'update_ready'
    version_obj.save(update_fields=['status'])
    
    # Update all installations with pending update
    installations = PluginInstallation.objects.filter(
        plugin=plugin,
        is_active=True
    ).exclude(current_version=version_obj)
    
    updated_count = installations.update(
        pending_update=version_obj,
        update_notified_at=timezone.now()
    )
    
    logger.info(f"Pushed update {plugin.name} v{version} to {updated_count} installations")
    
    return Response({
        'success': True,
        'message': f'Update pushed to {updated_count} installations',
        'installations_notified': updated_count,
    })


class AdminPluginInstallationsView(APIView):
    """View plugin installations (admin)."""
    permission_classes = [IsAdminUser]
    
    def get(self, request, slug=None):
        """List installations, optionally filtered by plugin."""
        if slug:
            plugin = get_object_or_404(Plugin, slug=slug)
            installations = PluginInstallation.objects.filter(plugin=plugin)
        else:
            installations = PluginInstallation.objects.all()
        
        installations = installations.select_related(
            'site', 'plugin', 'current_version', 'pending_update'
        )
        
        serializer = PluginInstallationSerializer(installations, many=True)
        return Response(serializer.data)


class AdminPluginStatsView(APIView):
    """Get plugin statistics (admin)."""
    permission_classes = [IsAdminUser]
    
    def get(self, request, slug=None):
        """Get download and installation statistics."""
        from django.db.models import Count
        from django.db.models.functions import TruncDate
        
        plugins_qs = Plugin.objects.all()
        if slug:
            plugins_qs = plugins_qs.filter(slug=slug)
        
        stats = []
        for plugin in plugins_qs:
            # Version distribution
            version_dist = PluginInstallation.objects.filter(
                plugin=plugin,
                is_active=True
            ).values('current_version__version').annotate(
                count=Count('id')
            ).order_by('-count')
            
            # Download counts by day (last 30 days)
            from datetime import timedelta
            thirty_days_ago = timezone.now() - timedelta(days=30)
            
            daily_downloads = PluginDownload.objects.filter(
                plugin=plugin,
                created_at__gte=thirty_days_ago
            ).annotate(
                date=TruncDate('created_at')
            ).values('date').annotate(
                count=Count('id')
            ).order_by('date')
            
            # Health status distribution
            health_dist = PluginInstallation.objects.filter(
                plugin=plugin
            ).values('health_status').annotate(
                count=Count('id')
            )
            
            stats.append({
                'plugin': plugin.slug,
                'name': plugin.name,
                'total_downloads': plugin.get_download_count(),
                'active_installations': PluginInstallation.objects.filter(
                    plugin=plugin, is_active=True
                ).count(),
                'version_distribution': list(version_dist),
                'daily_downloads': list(daily_downloads),
                'health_distribution': list(health_dist),
            })
        
        if slug and stats:
            return Response(stats[0])
        return Response(stats)


# ============================================================================
# Helper Functions
# ============================================================================

def get_client_ip(request):
    """Extract client IP from request."""
    x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
    if x_forwarded_for:
        ip = x_forwarded_for.split(',')[0].strip()
    else:
        ip = request.META.get('REMOTE_ADDR')
    return ip