use log::{debug, error, info, log_enabled, Level};
use netlink_packet_core::{NetlinkMessage, NetlinkPayload};
use netlink_packet_route::RouteNetlinkMessage as RtnlMessage;

use crate::CloudflareClient;

pub struct MessageHandler<'a> {
    cloudflare: &'a mut CloudflareClient,
    errs_counter: usize,
    errs_max: usize,
}

impl<'a> MessageHandler<'a> {
    pub fn new(cloudflare: &'a mut CloudflareClient, errs_max: usize) -> Self {
        Self {
            cloudflare,
            errs_counter: 0,
            errs_max,
        }
    }

    pub async fn handle_message(&mut self, message: NetlinkMessage<RtnlMessage>) -> Option<()> {
        match message.payload {
            NetlinkPayload::InnerMessage(RtnlMessage::NewAddress(msg)) => {
                if log_enabled!(Level::Debug) {
                    debug!("New IPv4 address message: {:?}", msg);
                } else {
                    info!("New IPv4 address");
                    if let Err(e) = self.cloudflare.check().await {
                        self.errs_counter += 1;
                        error!(
                            "Failed to check cloudflare ({}/{}): {:?}",
                            self.errs_counter, self.errs_max, &e
                        );
                        if self.errs_counter >= self.errs_max {
                            return None;
                        }
                    }
                }
            }
            NetlinkPayload::InnerMessage(RtnlMessage::DelAddress(msg)) => {
                if log_enabled!(Level::Debug) {
                    debug!("Deleted IPv4 address message: {:?}", msg);
                } else {
                    info!("Deleted IPv4 address");
                }
            }
            NetlinkPayload::InnerMessage(RtnlMessage::NewLink(link)) => {
                if log_enabled!(Level::Debug) {
                    debug!("New link message (interface connected): {:?}", link);
                } else {
                    info!("New link (interface connected)");
                    if let Err(e) = self.cloudflare.check().await {
                        self.errs_counter += 1;
                        error!(
                            "Failed to check cloudflare ({}/{}): {:?}",
                            self.errs_counter, self.errs_max, &e
                        );
                        if self.errs_counter >= self.errs_max {
                            return None;
                        }
                    }
                }
            }
            NetlinkPayload::InnerMessage(RtnlMessage::DelLink(link)) => {
                if log_enabled!(Level::Debug) {
                    debug!("Deleted link message (interface disconnected): {:?}", link);
                } else {
                    info!("Deleted link (interface disconnected)");
                }
            }
            _ => {
                if log_enabled!(Level::Debug) {
                    debug!("Unhandled message payload: {:?}", message.payload);
                }
            }
        }
        Some(())
    }
}