use envoy_types::ext_authz::v3::pb::CheckRequest;
use envoy_types::pb::envoy::service::auth::v3::AttributeContext;
use envoy_types::pb::envoy::service::auth::v3::attribute_context::{HttpRequest, Request};
use std::collections::HashMap;
use std::net::SocketAddr;
use std::str::FromStr;
use tonic::transport::Channel;

#[allow(dead_code)]
pub fn build<T: Default>() -> T {
    please::build()
}

pub fn build_with<T, F>(initializer: F) -> T
where
    T: Default,
    F: std::ops::FnOnce(&mut T),
{
    please::build_with(initializer)
}

pub fn build_request(f: impl std::ops::FnOnce(&mut HttpRequest)) -> CheckRequest {
    build_with(|item: &mut CheckRequest| {
        item.attributes = Some(please::build_with(|item: &mut AttributeContext| {
            item.request = Some(please::build_with(|item: &mut Request| {
                item.http = Some(please::build_with(|item: &mut HttpRequest| f(item)));
            }));
        }));
    })
}

pub fn build_headers(headers: Vec<(String, String)>) -> HashMap<String, String> {
    build_with(|item: &mut HashMap<String, String>| {
        for (key, value) in headers {
            item.insert(key, value);
        }
    })
}

pub fn build_cedar_authorizer(entities: cedar_policy::Entities) -> authzd::CedarAuthorizer {
    let realpath = std::fs::canonicalize("./etc/authzd").unwrap();
    let path = realpath.as_path();
    authzd::CedarAuthorizer::new_from(path, entities)
}

pub async fn build_channel(addr: SocketAddr) -> Channel {
    Channel::from_shared(format!("http://{}", addr))
        .expect("Failed to create channel")
        .connect()
        .await
        .expect("Failed to connect to server")
}

pub async fn build_rpc_client<T, F>(addr: SocketAddr, f: F) -> T
where
    F: FnOnce(Channel) -> T,
{
    f(build_channel(addr).await)
}

pub fn build_user(
    id: &str,
    attrs: std::collections::HashMap<String, cedar_policy::RestrictedExpression>,
) -> cedar_policy::Entity {
    cedar_policy::Entity::new(
        cedar_policy::EntityUid::from_type_name_and_id(
            cedar_policy::EntityTypeName::from_str("User").unwrap(),
            cedar_policy::EntityId::from_str(id).unwrap(),
        ),
        attrs,
        std::collections::HashSet::new(),
    )
    .unwrap()
}