# accounts/views/cloud_connect.py
import logging
from django.shortcuts import render, redirect
from django.contrib import messages
from django.utils.translation import gettext as _
from rest_framework import viewsets
from rest_framework.decorators import action
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
from google.oauth2.credentials import Credentials

from .base import DummySerializer

logger = logging.getLogger(__name__)


class CloudConnectViewSet(viewsets.ModelViewSet):
    """Handles connecting and displaying cloud storage accounts (Google Drive, Dropbox, OneDrive)"""
    serializer_class = DummySerializer
    
    ########## CONNECTING CLOUD ACCOUNTS AND FILE SELECTION WITH REAL DRIVE API ########## WILL ALSO ADD FOR THE OTHER APIS.
    @action(detail=False, methods=['get', 'post'], url_path=r'')
    def cloud_connect(self, request):
        """Step 1: Cloud Account Connection with Real Google Drive API"""
        base_domain = request.build_absolute_uri('/')
        user = request.user
        
        if not user.is_authenticated:
            return redirect(f'{base_domain}login/')
        
        context = {
            'base_domain': base_domain,
            'user': user,
            'current_step': 1,
            'cloud_services': self._get_cloud_services_info(user)
        }
        
        if request.method == 'POST':
            cloud_source = request.POST.get('cloud_source')
            if cloud_source in ['google_drive', 'dropbox', 'onedrive']:
                if cloud_source == 'google_drive':
                    # Initiate Google OAuth flow
                    request.session['selected_cloud'] = "google_drive"
                    return redirect(f'{base_domain}oauth/login/google-oauth2/?next={base_domain}transfer/new/')
                else:
                    # For other services, store selection and proceed
                    request.session['selected_cloud'] = cloud_source
                    request.session['cloud_connected'] = True
                    messages.info(request, f"{cloud_source.replace('_', ' ').title()} connection initiated")
                    print("I SHOULD GO TO THE TRANSFER WINDOW")
                    return redirect(f'{base_domain}transfer/new/')
            else:
                messages.error(request, "Please select a valid cloud service")
        
        return render(request, 'transfer.html', context)

    def _get_cloud_services_info(self, user):
        """Get real Google Drive info and dummy data for other services"""
        google_drive_info = self._get_google_drive_info(user)
        
        return [
            google_drive_info,
            
            #Replace with real API calls for Dropbox
            {
                'id': 'dropbox',
                'name': 'Dropbox',
                'icon': 'dropbox',
                'brand_color': '#0061FF',
                'description': 'Access files from your Dropbox account',
                'storage_quota': '2 GB free, upgradable',
                'features': ['File sharing', 'Version history', 'Team folders'],
                'connected': False,
                'account_email': None,
                'used_storage': '0 GB',
                'total_storage': '2 GB',
                'file_count': 0
            },
            
             #Replace with real API calls for Onedrive
            {
                'id': 'onedrive',
                'name': 'OneDrive',
                'icon': 'microsoft',
                'brand_color': '#0078D4',
                'description': 'Access files from your Microsoft OneDrive',
                'storage_quota': '5 GB free',
                'features': ['Office Online', 'Personal vault', 'File sharing'],
                'connected': False,
                'account_email': None,
                'used_storage': '0 GB',
                'total_storage': '5 GB',
                'file_count': 0
            }
        ] 
        
    def _get_google_drive_info(self, user):
        """Get real Google Drive information using the Google Drive API"""
        try:
            # Check if user has Google OAuth connected
            from social_django.models import UserSocialAuth
            social_auth = UserSocialAuth.objects.filter(
                user=user, 
                provider='google-oauth2'
            ).first()
            
            if social_auth:
                # Get access token from social auth
                access_token = social_auth.extra_data.get('access_token')
                
                if access_token:
                    # Create credentials object
                    credentials = Credentials(token=access_token)
                    
                    print("Access Token:", access_token)
                    
                    # Build Google Drive service
                    service = build('drive', 'v3', credentials=credentials)
                    
                    # Get storage quota
                    about = service.about().get(fields="storageQuota,user").execute()
                    storage_quota = about.get('storageQuota', {})
                    user_info = about.get('user', {})
                    
                    # Get file count
                    files = service.files().list(
                        pageSize=1,
                        fields="files(id,name),nextPageToken"
                    ).execute()
                    
                    # Calculate file count (approximate)
                    file_count = self._get_google_drive_file_count(service)
                    
                    # Format storage info
                    used_bytes = int(storage_quota.get('usage', 0))
                    total_bytes = int(storage_quota.get('limit', 0))
                    
                    used_gb = self._bytes_to_gb(used_bytes)
                    total_gb = self._bytes_to_gb(total_bytes)
                    usage_percentage = (used_bytes / total_bytes * 100) if total_bytes > 0 else 0
                    
                    return {
                        'id': 'google_drive',
                        'name': 'Google Drive',
                        'icon': 'google-drive',
                        'brand_color': '#4285F4',
                        'description': 'Access files from your Google Drive account',
                        'storage_quota': f'{total_gb} GB total',
                        'features': ['Docs, Sheets, Slides', 'Photo backup', 'Team drives'],
                        'connected': True,
                        'account_email': user_info.get('emailAddress', 'Connected'),
                        'used_storage': f'{used_gb:.1f} GB',
                        'total_storage': f'{total_gb} GB',
                        'usage_percentage': round(usage_percentage, 1),
                        'file_count': file_count,
                        'storage_details': {
                            'used_bytes': used_bytes,
                            'total_bytes': total_bytes,
                            'used_gb': used_gb,
                            'total_gb': total_gb
                        }
                    }
            
            # Fallback for users without Google OAuth or if API call fails
            return {
                'id': 'google_drive',
                'name': 'Google Drive',
                'icon': 'google-drive',
                'brand_color': '#4285F4',
                'description': 'Access files from your Google Drive account',
                'storage_quota': 'Connect to view storage',
                'features': ['Docs, Sheets, Slides', 'Photo backup', 'Team drives'],
                'connected': False,
                'account_email': None,
                'used_storage': '0 GB',
                'total_storage': '0 GB',
                'file_count': 0
            }
            
        except HttpError as error:
            print(f"Google Drive API error: {error}")
            # Return disconnected state on API error
            return {
                'id': 'google_drive',
                'name': 'Google Drive',
                'icon': 'google-drive',
                'brand_color': '#4285F4',
                'description': 'Access files from your Google Drive account',
                'storage_quota': 'Reconnect required',
                'features': ['Docs, Sheets, Slides', 'Photo backup', 'Team drives'],
                'connected': False,
                'account_email': None,
                'used_storage': '0 GB',
                'total_storage': '0 GB',
                'file_count': 0
            }
        except Exception as error:
            print(f"Unexpected error: {error}")
            return {
                'id': 'google_drive',
                'name': 'Google Drive',
                'icon': 'google-drive',
                'brand_color': '#4285F4',
                'description': 'Access files from your Google Drive account',
                'storage_quota': 'Connection error',
                'features': ['Docs, Sheets, Slides', 'Photo backup', 'Team drives'],
                'connected': False,
                'account_email': None,
                'used_storage': '0 GB',
                'total_storage': '0 GB',
                'file_count': 0
            }

    def _get_google_drive_file_count(self, service):
        """Get approximate file count from Google Drive"""
        try:
            # This gets a rough count - for exact count you'd need to paginate through all files
            result = service.files().list(
                pageSize=1000,
                fields="nextPageToken, files(id, name)"
            ).execute()
            
            files = result.get('files', [])
            return len(files)
        except:
            return 0

    def _bytes_to_gb(self, bytes_value):
        """Convert bytes to gigabytes"""
        return bytes_value / (1024 ** 3)