#!/usr/bin/env python3
"""Example script demonstrating the energy consumption ingester."""

import logging
from typing import Any

# Optional import for development
try:
    from dotenv import load_dotenv

    _load_dotenv: Any | None = load_dotenv
except ImportError:
    _load_dotenv = None

from energy_consumption_ingester import (
    EloverblikClient,
    DatabaseStorage,
    transform_metering_point_data,
    transform_consumption_data,
)


def main() -> None:
    """Example usage of the energy consumption ingester."""
    # Load environment variables from .env file (if available)
    if _load_dotenv is not None:
        _load_dotenv()

    # Set up logging
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)

    try:
        # Initialize the Eloverblik client
        logger.info("Initializing Eloverblik client...")
        client = EloverblikClient.from_env()

        # Initialize database storage
        logger.info("Initializing database connection...")
        db = DatabaseStorage.from_env()

        # Connect to database and create tables
        if not db.connect():
            logger.error("Failed to connect to database")
            return

        if not db.create_tables():
            logger.error("Failed to create database tables")
            return

        # Get metering points
        logger.info("Fetching metering points...")
        metering_points = client.get_metering_points()

        if not metering_points:
            logger.error("No metering points found")
            return

        logger.info(f"Found {len(metering_points)} metering points")

        # Process the first metering point
        mp_data = metering_points[0]
        metering_point_id = mp_data["meteringPointId"]

        logger.info(f"Processing metering point: {metering_point_id}")

        # Transform and store metering point data
        transformed_mp = transform_metering_point_data(mp_data)
        if db.store_metering_point(transformed_mp):
            logger.info("Metering point stored successfully")

        # Get consumption data for the last 7 days
        logger.info("Fetching consumption data...")
        consumption_data = client.get_consumption_data_last_days(
            metering_point_id, days=7
        )

        if consumption_data:
            # Transform consumption data
            _, readings = transform_consumption_data(consumption_data)

            if readings:
                # Store consumption readings
                if db.store_consumption_readings(metering_point_id, readings):
                    logger.info(f"Stored {len(readings)} consumption readings")

                    # Show some statistics
                    total_consumption = sum(r["consumption_kwh"] for r in readings)
                    avg_consumption = total_consumption / len(readings)

                    logger.info(f"Total consumption: {total_consumption:.2f} kWh")
                    logger.info(
                        f"Average hourly consumption: {avg_consumption:.3f} kWh"
                    )
                else:
                    logger.error("Failed to store consumption readings")
            else:
                logger.warning("No consumption readings to store")
        else:
            logger.warning("No consumption data retrieved")

    except Exception as e:
        logger.error(f"Error: {e}")
    finally:
        # Close database connection
        if "db" in locals():
            db.close()
            logger.info("Database connection closed")


if __name__ == "__main__":
    main()