from __future__ import annotations

from datetime import datetime

from app.processing.analyzers.device_analyzer import analyze_device_status
from app.processing.analyzers.trend_analyzer import analyze_trend
from app.processing.pipelines.report_pipeline import generate_device_report
from app.processing.pipelines.telemetry_pipeline import aggregate_telemetry
from app.processing.utils.dataframe_utils import to_records
from app.repositories.analytics_repo import AnalyticsRepository
from app.schemas.analytics import (
    AnalyticsResultRead,
    ReportResponse,
    TelemetryAggregateResponse,
)


class AnalyticsService:
    def __init__(self) -> None:
        self.analytics_repo = AnalyticsRepository()

    async def get_telemetry_aggregate(
        self, device_id: str, start: datetime, end: datetime, interval: str = "1h"
    ) -> TelemetryAggregateResponse:
        df = await aggregate_telemetry(device_id, start, end, interval)
        records = to_records(df) if len(df) > 0 else []
        return TelemetryAggregateResponse(
            device_id=device_id, records=records, count=len(records)
        )

    async def generate_report(
        self, device_id: str, start: datetime, end: datetime
    ) -> ReportResponse:
        result = await generate_device_report(device_id, start, end)
        return ReportResponse(
            report_id=str(result.id),
            device_id=device_id,
            status=result.result.get("status", {}),
            trends=result.result.get("trends", {}),
            created_at=result.created_at,
        )

    async def get_device_status_analysis(
        self, device_id: str, start: datetime, end: datetime
    ) -> dict:
        return await analyze_device_status(device_id, start, end)

    async def get_trend_analysis(
        self, device_id: str, start: datetime, end: datetime
    ) -> dict:
        return await analyze_trend(device_id, start, end)

    async def list_results(
        self, analysis_type: str, device_id: str | None = None, skip: int = 0, limit: int = 20
    ) -> list[AnalyticsResultRead]:
        results = await self.analytics_repo.get_by_type(
            analysis_type, device_id=device_id, skip=skip, limit=limit
        )
        return [
            AnalyticsResultRead(
                id=str(r.id),
                analysis_type=r.analysis_type,
                device_id=r.device_id,
                result=r.result,
                parameters=r.parameters,
                period_start=r.period_start,
                period_end=r.period_end,
                created_at=r.created_at,
            )
            for r in results
        ]