use libcwtch::event::{ContactIdentity, GroupID};

/// defines a locked list of allowed peers and groups the bot may communicate with
/// others will be blocked, and peers listed here will be peered with actively
pub struct AllowListMembers {
    /// list of peers to allow by handle
    pub peers: Vec<ContactIdentity>,
    /// list of groups to join and listen for peers in peer list from
    pub groups: Vec<GroupID>,
}

impl AllowListMembers {
    /// constructs a new AllowListMembers struct
    pub fn new(peers: Vec<ContactIdentity>, groups: Vec<GroupID>) -> Self {
        AllowListMembers {peers: peers, groups: groups}
    }
}

/// How new contacts should be treated
pub enum NewContactPolicy {
    /// Do not react, leave it for the custom event handler
    Ignore,
    /// Block all new contacts
    Block,
    /// Accept all new contacts
    Accept,
    /// AllowList is a list of handles that connections will be allowed from and connected to, and will be accepted
    ///   everything else will be ignored
    AllowList(AllowListMembers)
}

/// Settings for the bot on how it should automatically behave
pub struct Behaviour {
    /// The bot will enable experimental feautres (required for any experiments to be used)
    pub proto_experiments: bool,

    /// The bot will enable the file sharing experiment
    pub proto_experiment_fileshare: bool,

    /// The bot will enable the groups experiment
    pub proto_experiment_groups: bool,

    /// The profile name the bot will share with accepted conversations
    pub profile_name: String,
    /// The profile pic the bot with share with accepted conversations IF the file share exoeriment is enabled
    pub profile_pic_path: Option<String>,

    /// Policy dictacting how the bot should automatically handle ContactCreated events
    pub new_contant_policy: NewContactPolicy,
}

/// intermediary struct for building a Behaviour using builder patern
pub struct BehaviourBuilder {
    behaviour: Behaviour,
}

impl BehaviourBuilder {
    /// Returns a new empty default off for features behaviour builder
    pub fn new() -> Self {
        return BehaviourBuilder {
            behaviour: Behaviour {
                proto_experiments: false,
                proto_experiment_fileshare: false,
                proto_experiment_groups: false,
                new_contant_policy: NewContactPolicy::Ignore,
                profile_name: "".to_string(),
                profile_pic_path: None,
            },
        };
    }

    /// Build the defined behaviours into a Behaviour struct
    pub fn build(self) -> Behaviour {
        self.behaviour
    }

    /// Control if the Behaviour of the bot should include groups (enabling experiments and the group experiment)
    pub fn groups(mut self, val: bool) -> Self {
        self.behaviour.proto_experiment_groups = val;
        self.behaviour.proto_experiments = true;
        self
    }

    /// Control if the Behaviour of the bot should include filesharing (enabling experiments and the filesharing experiment)
    pub fn fileshare(mut self, val: bool) -> Self {
        self.behaviour.proto_experiment_fileshare = val;
        self.behaviour.proto_experiments = true;
        self
    }

    /// Set a profile pic for the bot and enable the filesharing experiment
    pub fn profile_pic_path(mut self, val: String) -> Self {
        self.behaviour.profile_pic_path = Some(val);
        self.behaviour.proto_experiment_fileshare = true;
        self.behaviour.proto_experiments = true;
        self
    }

    /// Set a name for the behaviour
    pub fn name(mut self, val: String) -> Self {
        self.behaviour.profile_name = val;
        self
    }

    /// Set a new contact policy for the behaviour
    pub fn new_contact_policy(mut self, val: NewContactPolicy) -> Self {
        self.behaviour.new_contant_policy = val;
        self
    }
}