from django.shortcuts import render, redirect
from django.contrib import messages
from django.db.models import Q
from rest_framework import viewsets
from rest_framework.decorators import action
from .. models import TransferOrder

from .base import DummySerializer




class ClientOrderStatusViewSet(viewsets.ModelViewSet):
    """Handles displaying order status and details to clients"""
    serializer_class = DummySerializer
    
    @action(detail=False, methods=['get']) # url_path=r'status/(?P<order_id>[^/.]+)'
    def order_status(self, request, order_id=None):
        """Display comprehensive order status and details to client"""
        base_domain = request.build_absolute_uri('/')
        user = request.user
        
        if not user.is_authenticated:
            return redirect(f'{base_domain}login/')
        
        try:
            # Get the order, ensuring it belongs to the current user
            order = TransferOrder.objects.get(
                Q(order_number=order_id),
                user=user
            )
            
            
            # Prepare order context with all required information
            context = {
                'base_domain': base_domain,
                'user': user,
                'order': order,
                'order_details': self._get_order_details(order),
                'status_info': self._get_status_information(order),
                'progress_data': self._get_progress_data(order),
                'timeline_events': self._get_timeline_events(order)
            }
            
            return render(request, 'client_detailed_order_status.html', context)
        
            
        except TransferOrder.DoesNotExist:
            messages.error(request, "Order not found or you don't have permission to view this order.")
            print("EROOR OCCURED HERE")
            return redirect(f'{base_domain}transfer/orders/')
        except Exception as e:
            print(f"Error retrieving order: {e}")
            messages.error(request, "An error occurred while retrieving order details.")
            return redirect(f'{base_domain}transfer/orders/')
        
        
    
    def _get_order_details(self, order):
        """Extract and format comprehensive order details"""
        return {
            'order_id': order.display_id,
            'cloud_service': self._get_cloud_service_display(order.cloud_source),
            'storage_device': self._get_storage_device_display(order),
            'total_file_size': f"{order.total_size} GB",
            'file_count': order.total_files,
            'payment_currency': order.payment_currency,
            'payment_status': self._get_payment_status(order),
            'payment_amount': f"{order.payment_amount} {order.payment_currency}",
            'download_status': self._get_download_status(order),
            'shipping_address': order.shipping_address or "Not provided yet",
            'estimated_completion': order.estimated_completion,
            'created_date': order.created_at,
            'last_updated': order.updated_at
        }
    
    def _get_status_information(self, order):
        """Get detailed status information with user-friendly messages"""
        status_messages = {
            'cloud_connected': {
                'title': 'Cloud Connected',
                'message': 'Your cloud storage has been successfully connected.',
                'icon': 'fas fa-cloud-check',
                'color': 'text-blue-600',
                'bg_color': 'bg-blue-50'
            },
            'files_selected': {
                'title': 'Files Selected',
                'message': f'You have selected {order.total_files} files totaling {order.total_size} GB.',
                'icon': 'fas fa-file-check',
                'color': 'text-green-600',
                'bg_color': 'bg-green-50'
            },
            'storage_selected': {
                'title': 'Storage Selected',
                'message': f'{order.get_storage_type_display()} selected for your files.',
                'icon': 'fas fa-hdd',
                'color': 'text-purple-600',
                'bg_color': 'bg-purple-50'
            },
            'payment_completed': {
                'title': 'Payment Completed',
                'message': f'Payment of {order.payment_amount} {order.payment_currency} has been processed successfully.',
                'icon': 'fas fa-check-circle',
                'color': 'text-green-600',
                'bg_color': 'bg-green-50'
            },
            'payment_pending': {
                'title': 'Payment Pending',
                'message': 'Waiting for payment confirmation.',
                'icon': 'fas fa-clock',
                'color': 'text-yellow-600',
                'bg_color': 'bg-yellow-50'
            },
            'download_in_progress': {
                'title': 'Download in Progress',
                'message': order.download_status or 'Your files are being downloaded from cloud storage.',
                'icon': 'fas fa-download',
                'color': 'text-blue-600',
                'bg_color': 'bg-blue-50'
            },
            'download_completed': {
                'title': 'Download Completed',
                'message': f'All files downloaded successfully on {order.download_completed_at}.',
                'icon': 'fas fa-check-double',
                'color': 'text-green-600',
                'bg_color': 'bg-green-50'
            },
            'download_failed': {
                'title': 'Download Failed',
                'message': order.download_status or 'There was an issue downloading your files. Our team has been notified.',
                'icon': 'fas fa-exclamation-triangle',
                'color': 'text-red-600',
                'bg_color': 'bg-red-50'
            },
            'download_partial': {
                'title': 'Partial Download',
                'message': order.download_status or 'Some files were downloaded successfully, but others failed.',
                'icon': 'fas fa-exclamation-circle',
                'color': 'text-orange-600',
                'bg_color': 'bg-orange-50'
            },
            'processing': {
                'title': 'Processing Files',
                'message': 'Your files are being processed and prepared for storage.',
                'icon': 'fas fa-cogs',
                'color': 'text-indigo-600',
                'bg_color': 'bg-indigo-50'
            },
            'shipped': {
                'title': 'Order Shipped',
                'message': 'Your storage device has been shipped and is on its way to you.',
                'icon': 'fas fa-shipping-fast',
                'color': 'text-teal-600',
                'bg_color': 'bg-teal-50'
            },
            'delivered': {
                'title': 'Delivered',
                'message': 'Your storage device has been delivered to your shipping address.',
                'icon': 'fas fa-box-open',
                'color': 'text-green-600',
                'bg_color': 'bg-green-50'
            },
            'completed': {
                'title': 'Order Completed',
                'message': 'Your order has been successfully completed.',
                'icon': 'fas fa-flag-checkered',
                'color': 'text-green-600',
                'bg_color': 'bg-green-50'
            },
            'cancelled': {
                'title': 'Order Cancelled',
                'message': 'This order has been cancelled.',
                'icon': 'fas fa-ban',
                'color': 'text-red-600',
                'bg_color': 'bg-red-50'
            }
        }
        
        return status_messages.get(order.status, {
            'title': order.get_status_display(),
            'message': 'Your order is being processed.',
            'icon': 'fas fa-info-circle',
            'color': 'text-gray-600',
            'bg_color': 'bg-gray-50'
        })
    
    def _get_progress_data(self, order):
        """Calculate progress through order workflow"""
        progress_steps = [
            {'name': 'Cloud Connected', 'status': 'cloud_connected'},
            {'name': 'Files Selected', 'status': 'files_selected'},
            {'name': 'Storage Selected', 'status': 'storage_selected'},
            {'name': 'Payment Completed', 'status': 'payment_completed'},
            {'name': 'Files Downloaded', 'status': 'download_completed'},
            {'name': 'Processing', 'status': 'processing'},
            {'name': 'Shipped', 'status': 'shipped'},
            {'name': 'Delivered', 'status': 'delivered'},
            {'name': 'Completed', 'status': 'completed'}
        ]
        
        current_step_index = 0
        for i, step in enumerate(progress_steps):
            if order.status == step['status']:
                current_step_index = i
                break
            # For statuses that might not be in the exact progression
            if self._is_status_achieved(order.status, step['status']):
                current_step_index = i
                
        print(f"Current Step Index: {current_step_index}")
        
        progress_percentage = int((current_step_index / (len(progress_steps) - 1)) * 100)
        
        return {
            'current_step': current_step_index + 1,
            'total_steps': len(progress_steps),
            'percentage': progress_percentage,
            'steps': progress_steps,
            'current_step_name': progress_steps[current_step_index]['name'] if current_step_index < len(progress_steps) else 'Processing'
        }
    
    def _get_timeline_events(self, order):
        """Generate timeline of order events"""
        timeline = []
        
        # Order created
        timeline.append({
            'date': order.created_at,
            'title': 'Order Created',
            'description': f'Order {order.display_id} was created.',
            'icon': 'fas fa-shopping-cart',
            'status': 'completed'
        })
        
        # Cloud connected
        if order.status in ['cloud_connected', 'files_selected', 'storage_selected', 
                           'payment_completed', 'payment_pending', 'download_in_progress',
                           'download_completed', 'download_failed', 'download_partial',
                           'processing', 'shipped', 'delivered', 'completed']:
            timeline.append({
                'date': order.created_at,  # Approximate - you might want to track this separately
                'title': 'Cloud Storage Connected',
                'description': f'{self._get_cloud_service_display(order.cloud_source)} connected successfully.',
                'icon': 'fas fa-cloud',
                'status': 'completed'
            })
        
        # Files selected
        if order.status in ['files_selected', 'storage_selected', 'payment_completed', 
                           'payment_pending', 'download_in_progress', 'download_completed',
                           'download_failed', 'download_partial', 'processing', 'shipped', 
                           'delivered', 'completed']:
            timeline.append({
                'date': order.updated_at,  # Approximate
                'title': 'Files Selected',
                'description': f'{order.total_files} files ({order.total_size} GB) selected for transfer.',
                'icon': 'fas fa-file-import',
                'status': 'completed'
            })
        
        # Storage selected
        if order.status in ['storage_selected', 'payment_completed', 'payment_pending',
                           'download_in_progress', 'download_completed', 'download_failed',
                           'download_partial', 'processing', 'shipped', 'delivered', 'completed']:
            timeline.append({
                'date': order.updated_at,  # Approximate
                'title': 'Storage Device Selected',
                'description': f'{self._get_storage_device_display(order)} selected.',
                'icon': 'fas fa-hdd',
                'status': 'completed'
            })
        
        # Payment events
        if order.status in ['payment_completed', 'download_in_progress', 'download_completed',
                           'download_failed', 'download_partial', 'processing', 'shipped',
                           'delivered', 'completed']:
            timeline.append({
                'date': order.updated_at,  # Approximate
                'title': 'Payment Processed',
                'description': f'Payment of {order.payment_amount} {order.payment_currency} completed.',
                'icon': 'fas fa-credit-card',
                'status': 'completed'
            })
        elif order.status == 'payment_pending':
            timeline.append({
                'date': order.updated_at,
                'title': 'Payment Pending',
                'description': 'Waiting for payment confirmation.',
                'icon': 'fas fa-clock',
                'status': 'pending'
            })
        
        # Download events
        if order.download_started_at:
            timeline.append({
                'date': order.download_started_at,
                'title': 'Download Started',
                'description': 'Started downloading files from cloud storage.',
                'icon': 'fas fa-download',
                'status': 'completed'
            })
        
        if order.download_completed_at:
            timeline.append({
                'date': order.download_completed_at,
                'title': 'Download Completed',
                'description': 'All files downloaded successfully.',
                'icon': 'fas fa-check-circle',
                'status': 'completed'
            })
        
        # Sort timeline by date
        timeline.sort(key=lambda x: x['date'])
        
        return timeline
    
    def _get_cloud_service_display(self, cloud_source):
        """Get user-friendly cloud service name"""
        cloud_services = {
            'google_drive': 'Google Drive',
            'dropbox': 'Dropbox',
            'onedrive': 'OneDrive'
        }
        return cloud_services.get(cloud_source, cloud_source)
    
    def _get_storage_device_display(self, order):
        """Get user-friendly storage device name"""
        if order.storage_type:
            storage_devices = {
                'flash_drive': f'USB Flash Drive ({order.storage_size})',
                'memory_card': f'Memory Card ({order.storage_size})',
                'external_hdd': f'External Hard Drive ({order.storage_size})'
            }
            return storage_devices.get(order.storage_type, order.get_storage_type_display())
        return "Not selected yet"
    
    def _get_payment_status(self, order):
        """Determine payment status based on order status"""
        if order.status in ['payment_completed', 'download_in_progress', 'download_completed',
                           'download_failed', 'download_partial', 'processing', 'shipped',
                           'delivered', 'completed']:
            return 'Completed'
        elif order.status == 'payment_pending':
            return 'Pending'
        else:
            return 'Not Required Yet'
    
    def _get_download_status(self, order):
        """Get detailed download status"""
        if order.download_completed_at:
            return f'Completed on {order.download_completed_at}'
        elif order.download_started_at:
            return f'In Progress - Started {order.download_started_at}'
        elif order.status in ['payment_completed', 'storage_selected']:
            return 'Ready to Download'
        else:
            return 'Not Started'
    
    def _is_status_achieved(self, current_status, target_status):
        """Check if a status step has been achieved in the workflow"""
        status_hierarchy = [
            'cloud_connected',
            'files_selected', 
            'storage_selected',
            'payment_completed',
            'download_completed',
            'processing',
            'shipped',
            'delivered',
            'completed'
        ]
        
        try:
            current_index = status_hierarchy.index(current_status)
            target_index = status_hierarchy.index(target_status)
            return current_index >= target_index
        except ValueError:
            return False
    
    @action(detail=False, methods=['get']) # url_path=r'transfer/orders'
    def user_orders(self, request):
        """Display all orders for the current user"""
        base_domain = request.build_absolute_uri('/')
        user = request.user
        
        if not user.is_authenticated:
            return redirect(f'{base_domain}login/')
        
        # Get user's orders, ordered by most recent first
        orders = TransferOrder.objects.filter(user=user).order_by('-created_at')
        
        context = {
            'base_domain': base_domain,
            'user': user,
            'orders': orders,
            'orders_count': orders.count()
        }
        
        return render(request, 'client_order_status.html' , context)