piam-types 0.0.0

use std::{collections::HashMap, sync::Mutex};

use crate::{
    condition::{Condition, Conditions},
    effect::Effect,
    principal::{Group, Role, User, UserKind},
};

type PolicyByUser<T> = HashMap<User, Policy<T>>;
type PolicyByGroup<T> = HashMap<Group, Policy<T>>;
type PolicyByRole<T> = HashMap<Role, Policy<T>>;
type GroupByUser = HashMap<User, Group>;

pub struct PolicyContainer<T> {
    pub policy_by_user: PolicyByUser<T>,
    pub policy_by_group: PolicyByGroup<T>,
    pub policy_by_role: PolicyByRole<T>,
    pub groups: GroupByUser,
}

impl<T> PolicyContainer<T> {
    pub fn init() -> Self {
        Self {
            policy_by_user: PolicyByUser::new(),
            policy_by_group: PolicyByGroup::new(),
            policy_by_role: PolicyByRole::new(),
            groups: GroupByUser::new(),
        }
    }

    pub fn find_policy(&self, user: &User) -> Option<&T> {
        self.groups
            .get(user)
            .and_then(|group| self.policy_by_group.get(group))
            .map(|policy| &policy.type_)
    }
}

pub fn do_a_call() {
    // let user = User::default();
    // let group = Group::default();
    // GROUPS.lock().unwrap().insert(user, group);
    // let mut user1 = User::default();
    // dbg!(&GROUPS.lock().unwrap().get(&user1));
}

pub struct Policy<T> {
    pub version: i32,
    /// if condition specified, only takes effect when condition is met
    pub conditions: Vec<Conditions>,
    // TODO: put input output type together
    // TODO: use generic
    pub type_: T,
    pub effects: Vec<Effect>,
}

#[cfg(feature = "s3-policy")]
pub mod s3_policy {
    #[derive(Default)]
    pub struct S3Policy {
        pub input: S3InputPolicy,
        pub output: Option<String>,
    }

    #[derive(Default)]
    pub struct S3InputPolicy {
        bucket: Bucket,
        control: Option<Control>,
        outpost: Option<Outpost>,
    }

    impl S3InputPolicy {
        // pub fn find_by_user(user: &User) -> Option<&Policy> {
        //     let guard = GROUPS.lock().unwrap();
        //     let group = match guard.get(user) {
        //         None => return None,
        //         Some(group) => group,
        //     };
        //     POLICY_BY_GROUP.lock().unwrap().get(group)
        // }
    }

    #[derive(Default)]
    pub struct Bucket {
        name: Name,
        tag: Option<Tag>,
    }

    #[derive(Default)]
    pub struct Outpost;

    #[derive(Default)]
    pub struct Control;

    #[derive(Default)]
    pub struct Name {
        eq: Option<Vec<String>>,
        start_with: Option<Vec<String>>,
        in_: Option<Vec<String>>,
    }

    #[derive(Default)]
    pub struct Tag;
}