robotrt-middleware-core 0.1.0-beta.2

use std::time::{Duration, Instant};

use super::SimpleDiscovery;
use super::state_helpers::{
    DiscoveryEntryKind, active_count, collect_inactive_names, inactive_count,
    increment_prune_report, renew_lease, set_health,
};
use super::types::{DiscoveryInactiveReason, DiscoveryPruneReport, DiscoverySnapshot};

impl SimpleDiscovery {
    pub fn renew_topic_lease(&mut self, name: &str, ttl: Duration) -> bool {
        renew_lease(self.topics.contains(name), &mut self.topic_state, name, ttl)
    }

    pub fn renew_service_lease(&mut self, name: &str, ttl: Duration) -> bool {
        renew_lease(
            self.services.contains(name),
            &mut self.service_state,
            name,
            ttl,
        )
    }

    pub fn renew_mission_lease(&mut self, name: &str, ttl: Duration) -> bool {
        renew_lease(
            self.missions.contains(name),
            &mut self.mission_state,
            name,
            ttl,
        )
    }

    pub fn renew_endpoint_lease(&mut self, name: &str, ttl: Duration) -> bool {
        renew_lease(
            self.endpoints.contains_key(name),
            &mut self.endpoint_state,
            name,
            ttl,
        )
    }

    pub fn set_topic_health(&mut self, name: &str, healthy: bool) -> bool {
        set_health(
            self.topics.contains(name),
            &mut self.topic_state,
            name,
            healthy,
        )
    }

    pub fn set_service_health(&mut self, name: &str, healthy: bool) -> bool {
        set_health(
            self.services.contains(name),
            &mut self.service_state,
            name,
            healthy,
        )
    }

    pub fn set_mission_health(&mut self, name: &str, healthy: bool) -> bool {
        set_health(
            self.missions.contains(name),
            &mut self.mission_state,
            name,
            healthy,
        )
    }

    pub fn set_endpoint_health(&mut self, name: &str, healthy: bool) -> bool {
        set_health(
            self.endpoints.contains_key(name),
            &mut self.endpoint_state,
            name,
            healthy,
        )
    }

    pub fn prune_inactive(&mut self) -> DiscoveryPruneReport {
        let now = Instant::now();
        let mut report = DiscoveryPruneReport::default();

        let inactive_topics = collect_inactive_names(self.topics.iter(), &self.topic_state, now);
        for (name, reason) in inactive_topics {
            self.topics.remove(&name);
            self.topic_state.remove(&name);
            self.remove_labels_if_unused(&name);
            increment_prune_report(&mut report, reason, DiscoveryEntryKind::Topic);
        }

        let inactive_services =
            collect_inactive_names(self.services.iter(), &self.service_state, now);
        for (name, reason) in inactive_services {
            self.services.remove(&name);
            self.service_state.remove(&name);
            self.remove_labels_if_unused(&name);
            increment_prune_report(&mut report, reason, DiscoveryEntryKind::Service);
        }

        let inactive_missions =
            collect_inactive_names(self.missions.iter(), &self.mission_state, now);
        for (name, reason) in inactive_missions {
            self.missions.remove(&name);
            self.mission_state.remove(&name);
            self.remove_labels_if_unused(&name);
            increment_prune_report(&mut report, reason, DiscoveryEntryKind::Mission);
        }

        let inactive_endpoints =
            collect_inactive_names(self.endpoints.keys(), &self.endpoint_state, now);
        for (name, reason) in inactive_endpoints {
            self.endpoints.remove(&name);
            self.endpoint_state.remove(&name);
            self.remove_labels_if_unused(&name);
            increment_prune_report(&mut report, reason, DiscoveryEntryKind::Endpoint);
        }

        report
    }

    pub fn snapshot(&self) -> DiscoverySnapshot {
        let now = Instant::now();
        DiscoverySnapshot {
            topics: active_count(self.topics.iter(), &self.topic_state, now),
            services: active_count(self.services.iter(), &self.service_state, now),
            missions: active_count(self.missions.iter(), &self.mission_state, now),
            endpoints: active_count(self.endpoints.keys(), &self.endpoint_state, now),
            expired: inactive_count(
                self.topics.iter(),
                &self.topic_state,
                now,
                DiscoveryInactiveReason::Expired,
            ) + inactive_count(
                self.services.iter(),
                &self.service_state,
                now,
                DiscoveryInactiveReason::Expired,
            ) + inactive_count(
                self.missions.iter(),
                &self.mission_state,
                now,
                DiscoveryInactiveReason::Expired,
            ) + inactive_count(
                self.endpoints.keys(),
                &self.endpoint_state,
                now,
                DiscoveryInactiveReason::Expired,
            ),
            unhealthy: inactive_count(
                self.topics.iter(),
                &self.topic_state,
                now,
                DiscoveryInactiveReason::Unhealthy,
            ) + inactive_count(
                self.services.iter(),
                &self.service_state,
                now,
                DiscoveryInactiveReason::Unhealthy,
            ) + inactive_count(
                self.missions.iter(),
                &self.mission_state,
                now,
                DiscoveryInactiveReason::Unhealthy,
            ) + inactive_count(
                self.endpoints.keys(),
                &self.endpoint_state,
                now,
                DiscoveryInactiveReason::Unhealthy,
            ),
        }
    }
}