from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.utils import timezone
from .models import (
    Development, DevelopmentTranslate, Currency, 
    Feature, BuildingType, PaymentOption, Flat, FlatTranslate
)
from .serializers import (
    CurrencySerializer, DevelopmentListSerializer, FlatSerializer, 
    MasterDevelopmentSerializer
)
from .change_tracking import get_current_timestamp, timestamp_to_datetime


class SyncStatusView(APIView):
    """
    API endpoint that returns the latest update timestamp for each model
    """
    def get(self, request):
        # Get the latest update timestamps for each model
        latest_updates = {
            'developments': Development.objects.order_by('-updated_at').values('updated_at').first(),
            'development_translates': DevelopmentTranslate.objects.order_by('-updated_at').values('updated_at').first(),
            'currencies': Currency.objects.order_by('-updated_at').values('updated_at').first(),
            'features': Feature.objects.order_by('-updated_at').values('updated_at').first(),
            'building_types': BuildingType.objects.order_by('-updated_at').values('updated_at').first(),
            'payment_options': PaymentOption.objects.order_by('-updated_at').values('updated_at').first(),
            'flats': Flat.objects.order_by('-updated_at').values('updated_at').first(),
            'flat_translates': FlatTranslate.objects.order_by('-updated_at').values('updated_at').first(),
        }
        
        # Convert datetime to timestamps
        result = {}
        for key, value in latest_updates.items():
            if value and 'updated_at' in value:
                timestamp = value['updated_at'].timestamp()
                result[key] = timestamp
            else:
                result[key] = 0
                
        # Add current server timestamp
        result['server_time'] = get_current_timestamp()
        
        return Response(result)


class SyncDataView(APIView):
    """
    API endpoint that returns data that has changed since the given timestamp
    """
    def get(self, request):
        # Get the timestamp from the request
        since_timestamp = request.query_params.get('since', None)
        language = request.query_params.get('language', 'en')
        
        if not since_timestamp:
            return Response(
                {"error": "Missing 'since' parameter with timestamp"}, 
                status=status.HTTP_400_BAD_REQUEST
            )
            
        try:
            since_datetime = timestamp_to_datetime(float(since_timestamp))
        except ValueError:
            return Response(
                {"error": "Invalid timestamp format"}, 
                status=status.HTTP_400_BAD_REQUEST
            )
        
        # Get updated data for each model
        updated_data = {}
        
        # Get updated currencies
        updated_currencies = Currency.objects.filter(updated_at__gt=since_datetime)
        if updated_currencies.exists():
            updated_data['currencies'] = CurrencySerializer(updated_currencies, many=True).data
        
        # Get updated developments
        updated_developments_translate = DevelopmentTranslate.objects.select_related(
            'development', 'development__city', 'development__country'
        ).filter(
            updated_at__gt=since_datetime,
            language__code=language,
            development__is_active=True,
            development__is_deleted=False
        )
        if updated_developments_translate.exists():
            updated_data['developments'] = DevelopmentListSerializer(
                updated_developments_translate, many=True
            ).data
            
        # Get updated flats
        updated_flats = FlatTranslate.objects.select_related(
            'flat', 'flat__development'
        ).filter(
            updated_at__gt=since_datetime,
            language__code=language,
            flat__development__is_active=True
        )
        if updated_flats.exists():
            updated_data['flats'] = FlatSerializer(updated_flats, many=True).data
            
        # Add any developments that were updated but their translation wasn't
        updated_developments = Development.objects.filter(
            updated_at__gt=since_datetime,
            is_active=True,
            is_deleted=False
        ).exclude(
            translates__updated_at__gt=since_datetime,
            translates__language__code=language
        )
        if updated_developments.exists():
            # Get their translations
            dev_ids = updated_developments.values_list('id', flat=True)
            dev_translates = DevelopmentTranslate.objects.filter(
                development__id__in=dev_ids,
                language__code=language
            )
            if dev_translates.exists():
                if 'developments' not in updated_data:
                    updated_data['developments'] = []
                updated_data['developments'].extend(
                    DevelopmentListSerializer(dev_translates, many=True).data
                )
                
        # Add metadata
        result = {
            'sync_time': get_current_timestamp(),
            'data': updated_data
        }
        
        return Response(result)


class FullSyncView(APIView):
    """
    API endpoint that returns all active data for a full sync
    """
    def get(self, request):
        language = request.query_params.get('language', 'en')
        
        # Get all active data
        all_data = {}
        
        # Get all currencies
        all_currencies = Currency.objects.all()
        all_data['currencies'] = CurrencySerializer(all_currencies, many=True).data
        
        # Get all developments
        all_developments_translate = DevelopmentTranslate.objects.select_related(
            'development', 'development__city', 'development__country'
        ).filter(
            language__code=language,
            development__is_active=True,
            development__is_deleted=False
        )
        all_data['developments'] = DevelopmentListSerializer(
            all_developments_translate, many=True
        ).data
            
        # Get all flats
        all_flats = FlatTranslate.objects.select_related(
            'flat', 'flat__development'
        ).filter(
            language__code=language,
            flat__development__is_active=True
        )
        all_data['flats'] = FlatSerializer(all_flats, many=True).data
        
        # Add metadata
        result = {
            'sync_time': get_current_timestamp(),
            'data': all_data
        }
        
        return Response(result)