use heromodels::db::Db;
use macros::{
    register_authorized_create_by_id_fn, register_authorized_delete_by_id_fn,
    register_authorized_get_by_id_fn,
};
use rhai::plugin::*;
use rhai::{Dynamic, Engine, EvalAltResult, Module, INT};
use std::mem;
use std::sync::Arc;

use heromodels::db::hero::OurDB;
use heromodels::db::Collection;
use heromodels::models::flow::signature_requirement::SignatureRequirement;

type RhaiSignatureRequirement = SignatureRequirement;

#[export_module]
mod rhai_signature_requirement_module {
    use super::{RhaiSignatureRequirement, INT};

    #[rhai_fn(name = "new_signature_requirement", return_raw)]
    pub fn new_signature_requirement() -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        Ok(SignatureRequirement::default())
    }

    // --- Setters ---
    #[rhai_fn(name = "flow_step_id", return_raw)]
    pub fn set_flow_step_id(
        sr: &mut RhaiSignatureRequirement,
        flow_step_id: INT,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let mut owned = std::mem::take(sr);
        owned.flow_step_id = flow_step_id as u32;
        *sr = owned;
        Ok(sr.clone())
    }

    #[rhai_fn(name = "public_key", return_raw)]
    pub fn set_public_key(
        sr: &mut RhaiSignatureRequirement,
        public_key: String,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let mut owned = std::mem::take(sr);
        owned.public_key = public_key;
        *sr = owned;
        Ok(sr.clone())
    }

    #[rhai_fn(name = "message", return_raw)]
    pub fn set_message(
        sr: &mut RhaiSignatureRequirement,
        message: String,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let mut owned = std::mem::take(sr);
        owned.message = message;
        *sr = owned;
        Ok(sr.clone())
    }

    #[rhai_fn(name = "signed_by", return_raw)]
    pub fn set_signed_by(
        sr: &mut RhaiSignatureRequirement,
        signed_by: String,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let owned = std::mem::take(sr);
        *sr = owned.signed_by(signed_by);
        Ok(sr.clone())
    }

    #[rhai_fn(name = "signature", return_raw)]
    pub fn set_signature(
        sr: &mut RhaiSignatureRequirement,
        signature: String,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let owned = std::mem::take(sr);
        *sr = owned.signature(signature);
        Ok(sr.clone())
    }

    #[rhai_fn(name = "status", return_raw)]
    pub fn set_status(
        sr: &mut RhaiSignatureRequirement,
        status: String,
    ) -> Result<RhaiSignatureRequirement, Box<EvalAltResult>> {
        let owned = std::mem::take(sr);
        *sr = owned.status(status);
        Ok(sr.clone())
    }

    // --- Getters ---
    #[rhai_fn(get = "id", pure)]
    pub fn get_id(s: &mut RhaiSignatureRequirement) -> INT {
        s.base_data.id as INT
    }
    #[rhai_fn(get = "flow_step_id", pure)]
    pub fn get_flow_step_id(s: &mut RhaiSignatureRequirement) -> INT {
        s.flow_step_id as INT
    }
    #[rhai_fn(get = "public_key", pure)]
    pub fn get_public_key(s: &mut RhaiSignatureRequirement) -> String {
        s.public_key.clone()
    }
    #[rhai_fn(get = "message", pure)]
    pub fn get_message(s: &mut RhaiSignatureRequirement) -> String {
        s.message.clone()
    }
    #[rhai_fn(get = "signed_by", pure)]
    pub fn get_signed_by(s: &mut RhaiSignatureRequirement) -> Option<String> {
        s.signed_by.clone()
    }
    #[rhai_fn(get = "signature", pure)]
    pub fn get_signature(s: &mut RhaiSignatureRequirement) -> Option<String> {
        s.signature.clone()
    }
    #[rhai_fn(get = "status", pure)]
    pub fn get_status(s: &mut RhaiSignatureRequirement) -> String {
        s.status.clone()
    }
}

pub fn register_signature_requirement_rhai_module(engine: &mut Engine) {
    engine.build_type::<RhaiSignatureRequirement>();
    let mut module = exported_module!(rhai_signature_requirement_module);

    register_authorized_create_by_id_fn!(
        module: &mut module,
        rhai_fn_name: "save_signature_requirement",
        resource_type_str: "SignatureRequirement",
        rhai_return_rust_type: heromodels::models::flow::signature_requirement::SignatureRequirement
    );
    register_authorized_get_by_id_fn!(
        module: &mut module,
        rhai_fn_name: "get_signature_requirement",
        resource_type_str: "SignatureRequirement",
        rhai_return_rust_type: heromodels::models::flow::signature_requirement::SignatureRequirement
    );
    register_authorized_delete_by_id_fn!(
        module: &mut module,
        rhai_fn_name: "delete_signature_requirement",
        resource_type_str: "SignatureRequirement",
        rhai_return_rust_type: heromodels::models::flow::signature_requirement::SignatureRequirement
    );

    engine.register_global_module(module.into());
}