"""
/mnt/e/genesis-system/core/monitoring/metrics_collector.py

Gathers system metrics every minute and logs them.
"""

import logging
import time
import psutil
import json
from typing import Dict, Any

# Configure logging
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.StreamHandler()  # Logs to console
        # Optionally, add a FileHandler for persistent logging:
        # logging.FileHandler('/mnt/e/genesis-system/logs/metrics_collector.log')
    ]
)


class MetricsCollector:
    """
    Collects and logs system metrics.
    """

    def __init__(self):
        """
        Initializes the MetricsCollector.
        """
        self.logger = logging.getLogger(__name__)
        self.interval_seconds = 60  # Collect metrics every minute

    def get_cpu_metrics(self) -> Dict[str, Any]:
        """
        Collects CPU metrics.

        Returns:
            A dictionary containing CPU metrics.
        """
        try:
            cpu_percent = psutil.cpu_percent(interval=1)  # CPU usage percentage over 1 second
            cpu_count = psutil.cpu_count()
            cpu_freq = psutil.cpu_freq().current

            return {
                "cpu_percent": cpu_percent,
                "cpu_count": cpu_count,
                "cpu_frequency_mhz": cpu_freq
            }
        except Exception as e:
            self.logger.error(f"Error getting CPU metrics: {e}")
            return {}

    def get_memory_metrics(self) -> Dict[str, Any]:
        """
        Collects memory metrics.

        Returns:
            A dictionary containing memory metrics.
        """
        try:
            virtual_memory = psutil.virtual_memory()
            swap_memory = psutil.swap_memory()

            return {
                "total_memory_bytes": virtual_memory.total,
                "available_memory_bytes": virtual_memory.available,
                "used_memory_bytes": virtual_memory.used,
                "memory_percent": virtual_memory.percent,
                "swap_total_bytes": swap_memory.total,
                "swap_used_bytes": swap_memory.used,
                "swap_free_bytes": swap_memory.free,
                "swap_percent": swap_memory.percent
            }
        except Exception as e:
            self.logger.error(f"Error getting memory metrics: {e}")
            return {}

    def get_disk_metrics(self) -> Dict[str, Any]:
        """
        Collects disk metrics for the root partition.

        Returns:
            A dictionary containing disk metrics.
        """
        try:
            disk_usage = psutil.disk_usage('/')  # Root partition
            return {
                "disk_total_bytes": disk_usage.total,
                "disk_used_bytes": disk_usage.used,
                "disk_free_bytes": disk_usage.free,
                "disk_percent": disk_usage.percent
            }
        except Exception as e:
            self.logger.error(f"Error getting disk metrics: {e}")
            return {}

    def get_network_metrics(self) -> Dict[str, Any]:
         """
         Collects network metrics.

         Returns:
            A dictionary containing network metrics.
         """
         try:
             net_io = psutil.net_io_counters()
             return {
                 "bytes_sent": net_io.bytes_sent,
                 "bytes_recv": net_io.bytes_recv,
                 "packets_sent": net_io.packets_sent,
                 "packets_recv": net_io.packets_recv
             }
         except Exception as e:
             self.logger.error(f"Error getting network metrics: {e}")
             return {}


    def collect_metrics(self) -> Dict[str, Any]:
        """
        Collects all system metrics.

        Returns:
            A dictionary containing all collected metrics.
        """
        metrics = {
            "cpu": self.get_cpu_metrics(),
            "memory": self.get_memory_metrics(),
            "disk": self.get_disk_metrics(),
            "network": self.get_network_metrics()
        }
        return metrics

    def run(self):
        """
        Runs the metrics collection loop.
        """
        while True:
            try:
                metrics = self.collect_metrics()
                self.logger.info(f"System Metrics: {json.dumps(metrics)}")  # Log as JSON
            except Exception as e:
                self.logger.error(f"Error collecting metrics: {e}")
            time.sleep(self.interval_seconds)


if __name__ == "__main__":
    collector = MetricsCollector()
    collector.run()