use crate::permission::types::*;
use crate::*;
use common_data::change_control::ChangeControl;
use near_sdk::{env, Promise};

impl Contract {
    /// Execute kernel configuration function via proposal system
    /// This is called from the proposal execution system after approval threshold is reached
    pub fn internal_execute_kernel_function_via_proposal(
        &mut self,
        policy_id: &str,
        function_args: &serde_json::Value,
    ) -> Option<Promise> {
        // // Ensure pending config is activated if ready
        // self.ensure_active_config();

        match policy_id {
            "grant_role" => {
                let role_id: String = serde_json::from_value(function_args["role_id"].clone())
                    .expect("Invalid role_id parameter");
                let target: RoleTarget = serde_json::from_value(function_args["target"].clone())
                    .expect("Invalid target parameter");
                self.internal_grant_role(role_id, target);
            }
            "revoke_role" => {
                let role_id: String = serde_json::from_value(function_args["role_id"].clone())
                    .expect("Invalid role_id parameter");
                let target: RoleTarget = serde_json::from_value(function_args["target"].clone())
                    .expect("Invalid target parameter");
                self.internal_revoke_role(role_id, target);
            }
            "upsert_policy" => {
                let target_policy_id: String =
                    serde_json::from_value(function_args["target_policy_id"].clone())
                        .expect("Invalid target_policy_id parameter");
                let updated_policy: Policy =
                    serde_json::from_value(function_args["policy"].clone())
                        .expect("Invalid policy parameter");

                // Use proposal method for activation delay
                self.internal_propose_policy_change(target_policy_id, updated_policy);
            }
            "update_policy_change_control" => {
                let new_control: ChangeControl =
                    serde_json::from_value(function_args["change_control"].clone())
                        .expect("Invalid config parameter");

                // Use proposal method for activation delay
                self.internal_update_policy_change_control(new_control);
            }
            "cancel_pending_policy" => {
                let policy_id: String = serde_json::from_value(function_args["policy_id"].clone())
                    .expect("Invalid policy_id parameter");
                self.internal_cancel_pending_policy(policy_id);
            }
            "force_activate_policy" => {
                let policy_id: String = serde_json::from_value(function_args["policy_id"].clone())
                    .expect("Invalid policy_id parameter");
                self.internal_force_activate_policy(policy_id);
            }
            "acquire_lock" => {
                self.internal_acquire_lock();
            }
            "release_lock" => {
                self.internal_release_lock();
            }
            "force_release_lock" => {
                self.internal_force_release_lock();
            }
            "force_complete_pending_action" => {
                let policy_id: String = serde_json::from_value(function_args["policy_id"].clone())
                    .expect("Invalid policy_id parameter");
                self.internal_force_complete_pending_action(policy_id);
            }
            "batch_update_policies" => {
                let policies: Vec<Policy> =
                    serde_json::from_value(function_args["policies"].clone())
                        .expect("Invalid policies parameter");

                for policy in policies {
                    // Use proposal method for activation delay
                    self.internal_propose_policy_change(policy.id.clone(), policy);
                }
            }
            "store_data" => {
                let key: String = serde_json::from_value(function_args["key"].clone())
                    .expect("Invalid key parameter");
                let value: String = serde_json::from_value(function_args["value"].clone())
                    .expect("Invalid value parameter");
                self.internal_store_data(key, value);
            }
            "batch_store_data" => {
                let keys: Vec<String> = serde_json::from_value(function_args["keys"].clone())
                    .expect("Invalid keys parameter");
                let values: Vec<String> = serde_json::from_value(function_args["values"].clone())
                    .expect("Invalid values parameter");
                self.internal_batch_store_data(keys, values);
            }
            "delete_uploaded_contract" => {
                let code_hash: String = serde_json::from_value(function_args["code_hash"].clone())
                    .expect("Invalid code_hash parameter");
                self.internal_delete_uploaded_contract(code_hash);
            }
            "deploy_uploaded_contract" => {
                let code_hash: String = serde_json::from_value(function_args["code_hash"].clone())
                    .expect("Invalid code_hash parameter");
                return Some(self.internal_deploy_uploaded_contract(code_hash));
            }
            _ => env::panic_str(&format!(
                "Unknown kernel configuration policy: {}",
                policy_id
            )),
        }
        // all internal kernel operations with Promise should return earlier
        None
    }
}