use std::collections::HashMap;

use crate::core::models::{UnifiedData, UnifiedGroupData, UnifiedMonitorData};
use crate::data::{
    heartbeat::model::{HeartbeatEntry, HeartbeatResponse, UptimeData},
    status_page::model::StatusPageResponse,
};

pub fn unify_data(status_page: &StatusPageResponse, heartbeat: &HeartbeatResponse) -> UnifiedData {
    let mut groups = Vec::with_capacity(status_page.public_group_list.len());
    let heartbeat_map: HashMap<u64, Vec<HeartbeatEntry>> = heartbeat
        .monitors
        .iter()
        .map(|m| (m.monitor_id, m.heartbeats.clone()))
        .collect();

    let uptime_map: HashMap<(u64, u32), UptimeData> = heartbeat
        .uptime_data
        .iter()
        .map(|u| ((u.monitor_id, u.period_hours), u.clone()))
        .collect();

    for group in &status_page.public_group_list {
        let mut monitors = Vec::with_capacity(group.monitor_list.len());
        for monitor_info in &group.monitor_list {
            let uptime_data = uptime_map.get(&(monitor_info.id, 24)).cloned();
            let heartbeats = heartbeat_map
                .get(&monitor_info.id)
                .cloned()
                .unwrap_or_default();

            monitors.push(UnifiedMonitorData {
                id: monitor_info.id,
                name: monitor_info.name.clone(),
                heartbeats,
                uptime_data,
            });
        }

        monitors.sort_by_key(|m| m.id);

        groups.push(UnifiedGroupData {
            group_info: group.clone(),
            monitors,
        });
    }

    groups.sort_by_key(|g| g.group_info.weight);

    UnifiedData {
        title: status_page.config.title.clone(),
        description: status_page.config.description.clone(),
        groups,
        auto_refresh_interval: status_page.config.auto_refresh_interval,
    }
}