from functools import lru_cache
from datetime import datetime, timedelta
import hashlib

class CacheManager:
    def __init__(self):
        self.cache = {}
        
    def cache_key(self, device_ip, period, aggregation):
        """Generate cache key"""
        return hashlib.md5(
            f"{device_ip}:{period}:{aggregation}".encode()
        ).hexdigest()
    
    def get_cache_duration(self, period):
        """Determine cache duration based on period"""
        durations = {
            '24h': timedelta(minutes=5),
            '7d': timedelta(minutes=15),
            '30d': timedelta(hours=1),
            '3m': timedelta(hours=6),
            '6m': timedelta(hours=12),
            '1y': timedelta(days=1)
        }
        return durations.get(period, timedelta(minutes=5))
    
    @lru_cache(maxsize=128)
    def get_cached_data(self, key):
        """Get cached data if valid"""
        if key in self.cache:
            data, timestamp = self.cache[key]
            if datetime.now() - timestamp < self.get_cache_duration(period):
                return data
        return None

import asyncio
from concurrent.futures import ThreadPoolExecutor

async def fetch_device_data_async(device_ips):
    """Fetch data for multiple devices concurrently"""
    executor = ThreadPoolExecutor(max_workers=10)
    loop = asyncio.get_event_loop()
    
    tasks = [
        loop.run_in_executor(executor, fetch_device_data, ip)
        for ip in device_ips
    ]
    
    results = await asyncio.gather(*tasks)
    return results

def get_optimized_history(device_ip, period):
    """Optimized history query with aggregation"""
    
    # Determine optimal aggregation
    aggregation = get_auto_aggregation(period)
    
    # Use appropriate query based on period
    if period == '24h':
        # Use raw data for last 24 hours
        query = """
            SELECT timestamp, power_w, energy_kwh
            FROM readings
            WHERE device_ip = ? 
            AND timestamp > datetime('now', '-1 day')
            ORDER BY timestamp DESC
        """
    elif period in ['7d', '30d']:
        # Use hourly aggregates
        query = """
            SELECT 
                strftime('%Y-%m-%d %H:00:00', timestamp) as hour,
                AVG(power_w) as power_avg,
                SUM(energy_kwh) as energy_sum
            FROM readings
            WHERE device_ip = ?
            AND timestamp > datetime('now', ?)
            GROUP BY hour
            ORDER BY hour DESC
        """
    else:
        # Use daily aggregates for longer periods
        query = """
            SELECT 
                DATE(timestamp) as day,
                AVG(power_w) as power_avg,
                SUM(energy_kwh) as energy_sum
            FROM readings
            WHERE device_ip = ?
            AND timestamp > datetime('now', ?)
            GROUP BY day
            ORDER BY day DESC
        """
    
    return execute_query(query, params)

async def poll_devices_batch():
    """Poll devices in batches to avoid overwhelming the network"""
    batch_size = 10
    devices = get_all_devices()
    
    for i in range(0, len(devices), batch_size):
        batch = devices[i:i+batch_size]
        await asyncio.gather(*[poll_device(d) for d in batch])
        await asyncio.sleep(1)  # Pause between batches

def get_polling_interval(device):
    """Adjust polling interval based on device activity"""
    if device.is_active:
        return 30  # 30 seconds for active devices
    elif device.last_change < timedelta(hours=1):
        return 60  # 1 minute for recently changed
    else:
        return 300  # 5 minutes for idle devices

import psutil
import time

class PerformanceMonitor:
    def collect_metrics(self):
        return {
            'cpu_percent': psutil.cpu_percent(interval=1),
            'memory_percent': psutil.virtual_memory().percent,
            'disk_io': psutil.disk_io_counters(),
            'network_io': psutil.net_io_counters(),
            'process_count': len(psutil.pids()),
            'response_time': self.measure_response_time()
        }
    
    def measure_response_time(self):
        start = time.time()
        # Make test API call
        response = requests.get('http://localhost:5272/api/health')
        return time.time() - start