pub struct Contact {
    pub app: std::sync::Arc<crate::app::App>,
    pub token: std::sync::Arc<textsender_models::token::LoginResult>,
}

impl Contact {
    pub async fn get(
        &self,
        contact_id: &uuid::Uuid,
    ) -> Result<Vec<textsender_models::contact::Contact>, std::io::Error> {
        let client = reqwest::Client::new();
        let endpoint = format!("api/v1/contact?id={contact_id}");
        let api_url = format!("{}/{endpoint}", self.app.api_url);

        println!("Url: {api_url:?}");

        let (key, header) = super::auth_header(&self.token.access_token);

        match client.get(api_url).header(key, header).send().await {
            Ok(response) => match response.status() {
                reqwest::StatusCode::OK => match response.text().await {
                    Ok(val) => match parse_response(&val).await {
                        Ok(login_result) => Ok(login_result),
                        Err(err) => Err(err),
                    },
                    Err(err) => Err(std::io::Error::other(err)),
                },
                _ => Err(std::io::Error::other("Error getting token")),
            },
            Err(err) => Err(std::io::Error::other(err.to_string())),
        }
    }
}

async fn parse_response(
    response: &str,
) -> Result<Vec<textsender_models::contact::Contact>, std::io::Error> {
    match serde_json::from_str::<serde_json::Value>(response) {
        Ok(j) => match j.get("data") {
            Some(serde_json::Value::Array(lrs)) => {
                if lrs.is_empty() {
                    Err(std::io::Error::other("Error response is empty"))
                } else {
                    let mut events: Vec<textsender_models::contact::Contact> = Vec::new();

                    for event in lrs.iter() {
                        let ll: textsender_models::contact::Contact =
                            match serde_json::from_value(event.clone()) {
                                Ok(lr) => lr,
                                Err(err) => {
                                    return Err(std::io::Error::other(err.to_string()));
                                }
                            };
                        events.push(ll);
                    }

                    Ok(events)
                }
            }
            _ => Err(std::io::Error::other("Error parsing response")),
        },
        Err(err) => Err(std::io::Error::other(err.to_string())),
    }
}