use core::fmt::{Display, Write};

use defmt::{Format, Formatter};
use embassy_boot::FirmwareUpdaterError;
use embassy_net::{dns, tcp::ConnectError};
use embedded_io_async::ReadExactError;
use embedded_storage::nor_flash::NorFlashError;
use embedded_tls::TlsError;
use heapless::String;
use rust_mqtt::packet::v5::reason_codes::ReasonCode;

impl_tools::impl_scope! {
    #[derive(Debug)]
    pub enum Error<FE: NorFlashError + defmt::Format> {
        InvalidScheme,
        Mqtt(ReasonCode),
        Dns(dns::Error),
        Connect(ConnectError),
        Tls(TlsError),
        Reqwless(reqwless::Error),
        FirmwareUpdater(FirmwareUpdaterError),
        FlashError(FE),
        UnexpectedEof,
    }

    impl Self {
        pub fn string(&self) -> String<256> {
            let mut error = String::new();
            core::write!(error, "{}", self).expect("Formatting the error should not fail");
            error
        }
    }

    impl From<ReasonCode> for Self {
        fn from(error: ReasonCode) -> Self {
            Self::Mqtt(error)
        }
    }

    impl From<dns::Error> for Self {
        fn from(error: dns::Error) -> Self {
            Self::Dns(error)
        }
    }

    impl From<ConnectError> for Self {
        fn from(error: ConnectError) -> Self {
            Self::Connect(error)
        }
    }

    impl From<TlsError> for Self {
        fn from(error: TlsError) -> Self {
            Self::Tls(error)
        }
    }

    impl From<reqwless::Error> for Self {
        fn from(error: reqwless::Error) -> Self {
            Self::Reqwless(error)
        }
    }

    impl From<FirmwareUpdaterError> for Self {
        fn from(error: FirmwareUpdaterError) -> Self {
            Self::FirmwareUpdater(error)
        }
    }

    impl From<ReadExactError<reqwless::Error>> for Self {
        fn from(error: ReadExactError<reqwless::Error>) -> Self {
            match error {
                ReadExactError::UnexpectedEof => Self::UnexpectedEof,
                ReadExactError::Other(error) => Self::Reqwless(error),
            }
        }
    }

    impl Format for Self {
        fn format(&self, f: Formatter) {
            match self {
                Error::InvalidScheme => defmt::write!(f, "Invalid URL scheme"),
                Error::Mqtt(error) => defmt::write!(f, "Mqtt: {}", error),
                Error::Dns(error) => defmt::write!(f, "Dns: {}", error),
                Error::Connect(error) => defmt::write!(f, "Connect: {}", error),
                Error::Tls(error) => defmt::write!(f, "Tls: {}", error),
                Error::Reqwless(error) => defmt::write!(f, "Reqwless: {}", error),
                Error::FirmwareUpdater(error) => defmt::write!(f, "FirmwareUpdater: {}", error),
                Error::FlashError(error) => defmt::write!(f, "FlashError: {:?}", error),
                Error::UnexpectedEof => defmt::write!(f, "UnexpectedEof"),
            }
        }
    }

    impl Display for Self {
        fn fmt(&self, f: &mut core::fmt::Formatter) -> Result<(), core::fmt::Error> {
            match self {
                Error::InvalidScheme => core::write!(f, "Invalid URL scheme"),
                Error::Mqtt(error) => core::write!(f, "Mqtt: {}", error),
                Error::Dns(error) => core::write!(f, "Dns: {:?}", error),
                Error::Connect(error) => core::write!(f, "Connect: {:?}", error),
                Error::Tls(error) => core::write!(f, "Tls: {:?}", error),
                Error::Reqwless(error) => core::write!(f, "Reqwless: {:?}", error),
                Error::FirmwareUpdater(error) => core::write!(f, "FirmwareUpdater: {:?}", error),
                Error::FlashError(error) => core::write!(f, "FlashError: {:?}", error),
                Error::UnexpectedEof => core::write!(f, "UnexpectedEof"),
            }
        }
    }
}