// use rumqttc::QoS;

// use crate::AsyncClient;

pub static CLIENT_NAME: &str = "payments";

#[derive(Debug, thiserror::Error, serde::Serialize, serde::Deserialize)]
pub enum Error {
    #[error("Something went wrong")]
    InternalServerError,
}

#[derive(Debug, Copy, Clone)]
pub enum Topic {
    Succeed,
}

impl Topic {
    pub fn to_str(self) -> &'static str {
        match self {
            Topic::Succeed => "payments/succeed",
        }
    }
}

impl Into<String> for Topic {
    fn into(self) -> String {
        self.to_str().into()
    }
}

impl<'s> PartialEq<&'s str> for Topic {
    fn eq(&self, other: &&'s str) -> bool {
        self.to_str() == *other
    }
}

impl PartialEq<String> for Topic {
    fn eq(&self, other: &String) -> bool {
        self.to_str() == other.as_str()
    }
}

pub mod start_payment {
    use super::Error;

    #[derive(Debug, serde::Serialize, serde::Deserialize)]
    pub struct Input {}

    #[derive(Debug, serde::Serialize, serde::Deserialize)]
    pub struct Details {}

    pub type Output = Result<Details, Error>;
}

pub mod rpc {
    use config::SharedAppConfig;

    use crate::payments::start_payment;

    #[tarpc::service]
    pub trait Payments {
        async fn start_payment(input: start_payment::Input) -> start_payment::Output;
    }

    pub async fn create_client(config: SharedAppConfig) -> PaymentsClient {
        use tarpc::client;
        use tarpc::tokio_serde::formats::Bincode;

        let l = config.lock();
        let addr = l.orders_manager().rpc_addr();

        let transport = tarpc::serde_transport::tcp::connect(addr, Bincode::default);

        let client = PaymentsClient::new(
            client::Config::default(),
            transport.await.expect("Failed to connect to server"),
        )
        .spawn();

        client
    }
}

pub mod mqtt {
    use config::SharedAppConfig;
    use rumqttc::EventLoop;

    use super::CLIENT_NAME;
    use crate::AsyncClient;

    pub fn create_client(config: SharedAppConfig) -> (AsyncClient, EventLoop) {
        crate::mqtt::create_client(CLIENT_NAME, config.lock().stocks_manager().mqtt_addr())
    }
}