db/heromodels/src/models/calendar/rhai.rs

use rhai::{Engine, EvalAltResult, ImmutableString, NativeCallContext};
use std::sync::Arc;

use super::calendar::{AttendanceStatus, Attendee, Calendar, Event};
use crate::db::hero::OurDB;
use adapter_macros::rhai_timestamp_helpers;
use adapter_macros::{adapt_rhai_i64_input_fn, adapt_rhai_i64_input_method};
use heromodels_core::BaseModelData;

// Helper function for get_all_calendars registration

fn new_calendar_rhai(name: String) -> Result<Calendar, Box<EvalAltResult>> {
    Ok(Calendar::new(None, name))
}

fn new_event_rhai(
    context: NativeCallContext,
    title_rhai: ImmutableString,
    start_time_ts: i64,
    end_time_ts: i64,
) -> Result<Event, Box<EvalAltResult>> {
    let start_time =
        rhai_timestamp_helpers::rhai_timestamp_to_datetime(start_time_ts).map_err(|e_str| {
            Box::new(EvalAltResult::ErrorRuntime(
                format!("Failed to convert start_time for Event: {}", e_str).into(),
                context.position(),
            ))
        })?;

    let end_time =
        rhai_timestamp_helpers::rhai_timestamp_to_datetime(end_time_ts).map_err(|e_str| {
            Box::new(EvalAltResult::ErrorRuntime(
                format!("Failed to convert end_time for Event: {}", e_str).into(),
                context.position(),
            ))
        })?;

    Ok(Event::new(title_rhai.to_string(), start_time, end_time))
}

pub fn register_rhai_engine_functions(engine: &mut Engine, db: Arc<OurDB>) {
    engine.register_fn("name", move |calendar: Calendar, name: String| {
        Calendar::name(calendar, name)
    });
    engine.register_fn(
        "description",
        move |calendar: Calendar, description: String| Calendar::description(calendar, description),
    );
    engine.register_fn("add_event", Calendar::add_event);
    // Note: Event IDs are i64 in Calendar.events, but Event model's base_data.id is u32.
    // This might require adjustment if events are fetched by ID from the DB via Calendar.events.

    engine.register_fn(
        "new_event",
        |context: NativeCallContext,
         title_rhai: ImmutableString,
         start_time_ts: i64,
         end_time_ts: i64|
         -> Result<Event, Box<EvalAltResult>> {
            new_event_rhai(context, title_rhai, start_time_ts, end_time_ts)
        },
    );
    engine.register_fn("title", move |event: Event, title: String| {
        Event::title(event, title)
    });
    engine.register_fn("description", move |event: Event, description: String| {
        Event::description(event, description)
    });
    engine.register_fn(
        "add_attendee",
        adapt_rhai_i64_input_method!(Event, add_attendee, u32),
    );
    engine.register_fn(
        "remove_attendee",
        adapt_rhai_i64_input_method!(Event, remove_attendee, u32),
    );

    engine.register_fn("new_attendee", adapt_rhai_i64_input_fn!(Attendee::new, u32));

    engine.register_fn(
        "new_calendar",
        |name: String| -> Result<Calendar, Box<EvalAltResult>> { new_calendar_rhai(name) },
    );

    // Register a function to get the database instance
    engine.register_fn("get_db", move || db.clone());

    // Register getters for Calendar
    engine.register_get(
        "id",
        |c: &mut Calendar| -> Result<i64, Box<EvalAltResult>> { Ok(c.base_data.id as i64) },
    );
    engine.register_get(
        "name",
        |c: &mut Calendar| -> Result<String, Box<EvalAltResult>> {
            // println!("Rhai attempting to get Calendar.name: {}", c.name); // Debug print
            Ok(c.name.clone())
        },
    );
    engine.register_get(
        "description",
        |c: &mut Calendar| -> Result<Option<String>, Box<EvalAltResult>> {
            Ok(c.description.clone())
        },
    );

    // Register getter for Calendar.base_data
    engine.register_get(
        "base_data",
        |c: &mut Calendar| -> Result<BaseModelData, Box<EvalAltResult>> { Ok(c.base_data.clone()) },
    );

    // Register getters for BaseModelData
    engine.register_get(
        "id",
        |bmd: &mut BaseModelData| -> Result<i64, Box<EvalAltResult>> { Ok(bmd.id.into()) },
    );

    // Database interaction functions for Calendar are expected to be provided by #[rhai_model_export(..)] on the Calendar struct.
    // Ensure that `db.rs` or similar correctly wires up the `OurDB` methods for these.

    // Getters for Event
    engine.register_get("id", |e: &mut Event| -> Result<i64, Box<EvalAltResult>> {
        Ok(e.base_data.id as i64)
    });
    engine.register_get(
        "title",
        |e: &mut Event| -> Result<String, Box<EvalAltResult>> { Ok(e.title.clone()) },
    );
    // Add more getters for Event fields as needed
}