import logging
from celery import shared_task
from celery.exceptions import Retry
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime
import pytz
from time import sleep
import time

from .views import vast_handling
from .models import VastResponse
from .utils import vast_update_requests

# Configure logging
logger = logging.getLogger(__name__)

@shared_task(name="Call VAST", bind=True, max_retries=3)
def call_vast(self, url, num_requests, params, spot):
    """
    Enhanced VAST call task with proper error handling and resource management.
    
    Args:
        url (str): VAST endpoint URL
        num_requests (int): Number of concurrent requests
        params (dict): Request parameters
        spot: Ad spot identifier
        
    Returns:
        list: Results from VAST calls
    """
    try:
        logger.info(f"Starting VAST task for {num_requests} requests to {url}")
        
        # Limit concurrent workers to prevent resource exhaustion
        max_workers = min(num_requests, 20)  # Cap at 20 concurrent workers
        
        headers = {
            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/103.0.0.0 Safari/537.36'
        }
        
        results = []
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = []
            
            for i in range(1, num_requests + 1):
                future = executor.submit(
                    vast_handling, 
                    url, 
                    headers=headers, 
                    params=params, 
                    call_num=i, 
                    spot=spot
                )
                futures.append(future)
            
            # Collect results with timeout and error handling
            for i, future in enumerate(futures):
                try:
                    result = future.result(timeout=30)  # 30 second timeout per request
                    results.append(result)
                    logger.debug(f"VAST call {i+1}/{num_requests} completed successfully")
                except Exception as e:
                    logger.error(f"VAST call {i+1}/{num_requests} failed: {str(e)}")
                    results.append({'error': str(e), 'call_num': i+1})
        
        logger.info(f"VAST task completed: {len(results)} responses processed")
        return results
        
    except Exception as exc:
        logger.error(f"VAST task failed: {str(exc)}")
        # Retry with exponential backoff
        countdown = 2 ** self.request.retries * 60  # 1min, 2min, 4min
        self.retry(countdown=countdown, exc=exc)


@shared_task(name="update vast")
def update_vast():
    """
    Enhanced VAST update task with proper error handling.
    """
    try:
        logger.info("Starting VAST update task")
        
        from django.db.models import Q
        current_datetime = datetime.now()
        
        # Add your VAST update logic here
        # This is a placeholder for the actual implementation
        
        logger.info("VAST update task completed successfully")
        
    except Exception as e:
        logger.error(f"VAST update task failed: {str(e)}")
        raise