quoter/src/data.rs

use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE};
use reqwest::Client as HTTPClient;
use serde_json::{json, Value};
use std::collections::HashMap;
use std::env;
use std::error::Error;

pub async fn get_auth_id(token: &str) -> Result<i32, Box<dyn Error>> {
    let auth_api_base = env::var("AUTH_URL")?;
    let (query_name, query_type) = match auth_api_base.contains("auth.discours.io") {
        true => ("session", "query"),    // authorizer
        _ => ("getSession", "mutation"), // v2
    };
    let operation = "GetUserId";
    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_str(token)?);
    headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));

    let gql = json!({
        "query": format!("{} {} {{ {} {{ user {{ id }} }} }}", query_type, operation, query_name),
        "operationName": operation,
        "variables": HashMap::<String, String>::new()
    });

    let client = HTTPClient::new();
    let response = client
        .post(&auth_api_base)
        .headers(headers)
        .json(&gql)
        .send()
        .await?;

    if response.status().is_success() {
        let r: HashMap<String, serde_json::Value> = response.json().await?;
        let user_id = r
            .get("data")
            .and_then(|data| data.get(query_name))
            .and_then(|query| query.get("user"))
            .and_then(|user| user.get("id"))
            .and_then(|id| id.as_i64());

        match user_id {
            Some(id) => {
                println!("User ID retrieved: {}", id);
                Ok(id as i32)
            }
            None => {
                println!("No user ID found in the response");
                Err(Box::new(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    "No user ID found in the response",
                )))
            }
        }
    } else {
        println!("Request failed with status: {}", response.status());
        Err(Box::new(std::io::Error::new(
            std::io::ErrorKind::Other,
            format!("Request failed with status: {}", response.status()),
        )))
    }
}

async fn get_shout_followers(shout_id: &str) -> Result<Vec<i32>, Box<dyn Error>> {
    let api_base = env::var("API_BASE")?;
    let query = r#"query ShoutFollowers($shout: Int!) {
            shoutFollowers(shout: $shout) {
                follower {
                    id
                }
            }
        }
    "#;
    let shout_id = shout_id.parse::<i32>()?;
    let variables = json!({
        "shout": shout_id
    });
    let body = json!({
        "query": query,
        "operationName": "ShoutFollowers",
        "variables": variables
    });

    let client = reqwest::Client::new();
    let response = client.post(&api_base).json(&body).send().await?;

    if response.status().is_success() {
        let response_body: serde_json::Value = response.json().await?;
        let ids: Vec<i32> = response_body["data"]["shoutFollowers"]
            .as_array()
            .ok_or("Failed to parse follower array")?
            .iter()
            .filter_map(|f| f["follower"]["id"].as_i64().map(|id| id as i32))
            .collect();

        Ok(ids)
    } else {
        println!("Request failed with status: {}", response.status());
        Err(Box::new(std::io::Error::new(
            std::io::ErrorKind::Other,
            format!("Request failed with status: {}", response.status()),
        )))
    }
}

pub async fn is_fitting(
    listener_id: i32,
    kind: String,
    payload: HashMap<String, Value>,
) -> Result<bool, &'static str> {
    match &kind[0..9] {
        "new_react" => {
            // payload is Reaction, kind is new_reaction<reaction_kind>
            let shout_id = payload.get("shout").unwrap().as_str().unwrap();
            let recipients = get_shout_followers(shout_id).await.unwrap();

            Ok(recipients.contains(&listener_id))
        }
        "new_shout" => {
            // payload is Shout, kind is "new_shout"
            // TODO: check all community subscribers if no then
            // check all topics subscribers if no then
            // check all authors subscribers
            Ok(true)
        }
        "new_messa" => {
            println!("own message passed");
        },
        _ => {
            eprintln!("unknown payload kind");
            eprintln!("{:?}", payload);
            Ok(false)
        }
    }
}