pub fn get_split_count() -> u32 {

    web_sys::window()

        .and_then(|w| w.document())

        .and_then(|d| d.query_selector_all(".split-entry").ok())

        .map_or(0, |list| list.length())

}

pub fn setup_split_handlers() {

    setup_split_removal_handler();

    setup_currency_change_handler();

}

fn setup_split_removal_handler() {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let callback = Closure::wrap(Box::new(move |event: web_sys::MouseEvent| {

        let Some(target) = event.target() else {

            return;

        let Ok(el) = target.dyn_into::<HtmlElement>() else {

            return;

        if !el.class_list().contains("remove-split-btn") {

            return;

        }

        handle_split_removal(&el);

    }) as Box<dyn FnMut(_)>);

    let _ = document.add_event_listener_with_callback("click", callback.as_ref().unchecked_ref());

    callback.forget();

}

fn handle_split_removal(button: &HtmlElement) {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let split_count = document

        .query_selector_all(".split-entry")

        .map_or(0, |list| list.length());

    if split_count <= 1 {

        if let Some(window) = web_sys::window() {

            let _ = window.alert_with_message(

                "Cannot remove the last split. At least one split is required.",

            );

        }

        return;

    }

    let Some(split_entry) = button.closest(".split-entry").ok().flatten() else {

        return;

    split_entry.remove();

    update_split_labels();

}

fn update_split_labels() {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let Ok(splits) = document.query_selector_all(".split-entry") else {

        return;

    for i in 0..splits.length() {

        let Some(node) = splits.get(i) else {

            continue;

        let Ok(split) = node.dyn_into::<Element>() else {

            continue;

        if let Some(label) = split.query_selector(".split-label").ok().flatten() {

            label.set_text_content(Some(&format!("Split {}", i + 1)));

        }

        let _ = split.set_attribute("data-split-index", &i.to_string());

}

fn setup_currency_change_handler() {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let callback = Closure::wrap(Box::new(move |event: web_sys::Event| {

        let Some(target) = event.target() else {

            return;

        let Ok(input) = target.dyn_into::<HtmlInputElement>() else {

            return;

        let class_list = input.class_name();

        if !class_list.contains("commodity-value") {

            return;

        }

        let Some(split_entry) = input.closest(".split-entry").ok().flatten() else {

            return;

        check_currency_mismatch(&split_entry);

    }) as Box<dyn FnMut(_)>);

    let _ = document.add_event_listener_with_callback("change", callback.as_ref().unchecked_ref());

    callback.forget();

}

fn check_currency_mismatch(split_entry: &Element) {

    let from_commodity = split_entry

        .query_selector(r#".commodity-value[data-field="from-commodity"]"#)

        .ok()

        .flatten()

        .and_then(|el| el.dyn_into::<HtmlInputElement>().ok())

        .map(|input| input.value());

    let to_commodity = split_entry

        .query_selector(r#".commodity-value[data-field="to-commodity"]"#)

        .ok()

        .flatten()

        .and_then(|el| el.dyn_into::<HtmlInputElement>().ok())

        .map(|input| input.value());

    let Some(amount_converted_group) = split_entry

        .query_selector(".amount-converted-group")

        .ok()

        .flatten()

        return;

    let show_converted = match (from_commodity, to_commodity) {

        (Some(from), Some(to)) if !from.is_empty() && !to.is_empty() => from != to,

        _ => false,

    if show_converted {

        let _ = amount_converted_group.class_list().remove_1("hidden-field");

    } else {

        let _ = amount_converted_group.class_list().add_1("hidden-field");

    }

}

pub fn initialize_transaction_form() {

    let Some(window) = web_sys::window() else {

        return;

    let Some(document) = window.document() else {

        return;

    set_default_datetime(&document);

    fetch_initial_split();

}

fn set_default_datetime(document: &web_sys::Document) {

    let Some(date_input) = document

        .get_element_by_id("date")

        .and_then(|el| el.dyn_into::<HtmlInputElement>().ok())

        return;

    let current_value = date_input.value();

    if current_value.is_empty() {

        set_current_local_time(&date_input);

    } else {

        convert_utc_to_local(&date_input, &current_value);

    }

}

fn set_current_local_time(date_input: &HtmlInputElement) {

    let now = js_sys::Date::new_0();

    let offset_ms = now.get_timezone_offset() * 60.0 * 1000.0;

    let local_time = now.get_time() - offset_ms;

    let local_date = js_sys::Date::new(&JsValue::from_f64(local_time));

    let iso_string = local_date.to_iso_string();

    let datetime_local = iso_string

        .as_string()

        .map(|s| s.chars().take(16).collect::<String>())

        .unwrap_or_default();

    date_input.set_value(&datetime_local);

}

fn convert_utc_to_local(date_input: &HtmlInputElement, utc_value: &str) {

    let utc_string = format!("{utc_value}Z");

    let utc_date = js_sys::Date::new(&JsValue::from_str(&utc_string));

    if utc_date.get_time().is_nan() {

        return;

    }

    let offset_ms = utc_date.get_timezone_offset() * 60.0 * 1000.0;

    let local_time = utc_date.get_time() - offset_ms;

    let local_date = js_sys::Date::new(&JsValue::from_f64(local_time));

    let iso_string = local_date.to_iso_string();

    let datetime_local = iso_string

        .as_string()

        .map(|s| s.chars().take(16).collect::<String>())

        .unwrap_or_default();

    date_input.set_value(&datetime_local);

}

fn fetch_initial_split() {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let Some(container) = document.get_element_by_id("splits-container") else {

        return;

    autocomplete::init_all();

    if container

        .query_selector(".split-entry")

        .ok()

        .flatten()

        .is_some()

        if let Some(prefilled) = get_prefilled_account() {

            wasm_bindgen_futures::spawn_local(async move {

                prefill_from_account(&prefilled).await;

            });

        }

        return;

    }

    wasm_bindgen_futures::spawn_local(async move {

        let url = "/api/transaction/split/create?display_index=0";

        let Ok(response) = fetch_text(url).await else {

            web_sys::console::error_1(&"Error loading initial split".into());

            return;

        let Some(document) = web_sys::window().and_then(|w| w.document()) else {

            return;

        let Some(container) = document.get_element_by_id("splits-container") else {

            return;

        container.set_inner_html(&response);

        autocomplete::init_all();

        if let Some(prefilled) = get_prefilled_account() {

            prefill_from_account(&prefilled).await;

        }

    });

}

async fn fetch_text(url: &str) -> Result<String, JsValue> {

    let window = web_sys::window().ok_or("no window")?;

    let response = wasm_bindgen_futures::JsFuture::from(window.fetch_with_str(url)).await?;

    let response: web_sys::Response = response.dyn_into()?;

    let text = wasm_bindgen_futures::JsFuture::from(response.text()?).await?;

    text.as_string().ok_or_else(|| "not a string".into())

}

async fn fetch_json(url: &str) -> Result<String, JsValue> {

    let window = web_sys::window().ok_or("no window")?;

    let headers = web_sys::Headers::new()?;

    headers.set("Accept", "application/json")?;

    let opts = web_sys::RequestInit::new();

    opts.set_method("GET");

    opts.set_headers(&headers);

    let request = web_sys::Request::new_with_str_and_init(url, &opts)?;

    let response =

        wasm_bindgen_futures::JsFuture::from(window.fetch_with_request(&request)).await?;

    let response: web_sys::Response = response.dyn_into()?;

    let text = wasm_bindgen_futures::JsFuture::from(response.text()?).await?;

    text.as_string().ok_or_else(|| "not a string".into())

}

fn get_prefilled_account() -> Option<String> {

    let window = web_sys::window()?;

    js_sys::Reflect::get(&window, &"prefilledFromAccount".into())

        .ok()

        .and_then(|v| v.as_string())

}

async fn prefill_from_account(account_id: &str) {

    let Some(document) = web_sys::window().and_then(|w| w.document()) else {

        return;

    let Some(first_split) = document.query_selector(".split-entry").ok().flatten() else {

        return;

    let Some(hidden_input) = first_split

        .query_selector(r#".account-value[data-field="from-account"]"#)

        .ok()

        .flatten()

        .and_then(|el| el.dyn_into::<HtmlInputElement>().ok())

        return;

    let Some(display_input) = first_split

        .query_selector(r#".account-display[data-field="from-account"]"#)

        .ok()

        .flatten()

        .and_then(|el| el.dyn_into::<HtmlInputElement>().ok())

        return;

    hidden_input.set_value(account_id);

    let Ok(accounts_json) = fetch_json("/api/account/list").await else {

        return;

    let Ok(accounts) = serde_json::from_str::<Vec<AccountInfo>>(&accounts_json) else {

        return;

    if let Some(account) = accounts.iter().find(|a| a.id == account_id) {

        display_input.set_value(&account.name);

    }

}