hashtable.rs

use alloc::{string::String as RustString, vec, vec::Vec};

use java_class_proto::{JavaFieldProto, JavaMethodProto};
use java_constants::{ClassAccessFlags, MethodAccessFlags};
use jvm::{Array, ClassInstanceRef, JavaError, Jvm, Result, runtime::JavaLangString};

use crate::{
    RuntimeClassProto, RuntimeContext,
    classes::java::lang::{Object, String},
};

use super::HashtableEntry;

const DEFAULT_INITIAL_CAPACITY: i32 = 11;
const DEFAULT_LOAD_FACTOR: f32 = 0.75;

// class java.util.Hashtable
pub struct Hashtable;

impl Hashtable {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/util/Hashtable",
            parent_class: Some("java/util/Dictionary"),
            interfaces: vec!["java/util/Map", "java/lang/Cloneable", "java/io/Serializable"],
            methods: vec![
                JavaMethodProto::new("<init>", "()V", Self::init, Default::default()),
                JavaMethodProto::new("<init>", "(I)V", Self::init_with_capacity, Default::default()),
                JavaMethodProto::new("<init>", "(Ljava/util/Map;)V", Self::init_from_map, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("size", "()I", Self::size, Default::default()),
                JavaMethodProto::new("isEmpty", "()Z", Self::is_empty, Default::default()),
                JavaMethodProto::new("contains", "(Ljava/lang/Object;)Z", Self::contains, Default::default()),
                JavaMethodProto::new("containsKey", "(Ljava/lang/Object;)Z", Self::contains_key, Default::default()),
                JavaMethodProto::new("containsValue", "(Ljava/lang/Object;)Z", Self::contains_value, Default::default()),
                JavaMethodProto::new("keys", "()Ljava/util/Enumeration;", Self::keys, Default::default()),
                JavaMethodProto::new("elements", "()Ljava/util/Enumeration;", Self::elements, Default::default()),
                JavaMethodProto::new(
                    "put",
                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
                    Self::put,
                    Default::default(),
                ),
                JavaMethodProto::new(
                    "putAll",
                    "(Ljava/util/Map;)V",
                    Self::put_all,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, Default::default()),
                JavaMethodProto::new("remove", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::remove, Default::default()),
                JavaMethodProto::new("clear", "()V", Self::clear, Default::default()),
                JavaMethodProto::new("keySet", "()Ljava/util/Set;", Self::key_set, Default::default()),
                JavaMethodProto::new("values", "()Ljava/util/Collection;", Self::values, Default::default()),
                JavaMethodProto::new("entrySet", "()Ljava/util/Set;", Self::entry_set, Default::default()),
                JavaMethodProto::new("rehash", "()V", Self::rehash, MethodAccessFlags::PROTECTED),
                JavaMethodProto::new(
                    "equals",
                    "(Ljava/lang/Object;)Z",
                    Self::equals,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new(
                    "hashCode",
                    "()I",
                    Self::hash_code,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED,
                ),
                JavaMethodProto::new("toString", "()Ljava/lang/String;", Self::to_string, Default::default()),
            ],
            fields: vec![
                JavaFieldProto::new("table", "[Ljava/util/Hashtable$Entry;", Default::default()),
                JavaFieldProto::new("count", "I", Default::default()),
                JavaFieldProto::new("threshold", "I", Default::default()),
                JavaFieldProto::new("loadFactor", "F", Default::default()),
            ],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.util.Hashtable::<init>({this:?})");

        jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (DEFAULT_INITIAL_CAPACITY,))
            .await
    }

    async fn init_with_capacity(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>, initial_capacity: i32) -> Result<()> {
        tracing::debug!("java.util.Hashtable::<init>({this:?}, {initial_capacity:?})");

        if initial_capacity < 0 {
            return Err(jvm.exception("java/lang/IllegalArgumentException", "Illegal Capacity").await);
        }

        let _: () = jvm.invoke_special(&this, "java/util/Dictionary", "<init>", "()V", ()).await?;

        let initial_capacity = initial_capacity.max(1);
        let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", initial_capacity as usize).await?;
        jvm.put_field(&mut this, "table", "[Ljava/util/Hashtable$Entry;", table).await?;
        jvm.put_field(&mut this, "count", "I", 0).await?;
        jvm.put_field(&mut this, "threshold", "I", (initial_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
            .await?;
        jvm.put_field(&mut this, "loadFactor", "F", DEFAULT_LOAD_FACTOR).await?;

        Ok(())
    }

    async fn init_from_map(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
        tracing::debug!("java.util.Hashtable::<init>({this:?}, {map:?})");

        if map.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
        }
        let size: i32 = jvm.invoke_virtual(&map, "size", "()I", ()).await?;
        let capacity = size.saturating_mul(2).max(DEFAULT_INITIAL_CAPACITY);
        let _: () = jvm.invoke_special(&this, "java/util/Hashtable", "<init>", "(I)V", (capacity,)).await?;
        let _: () = jvm.invoke_virtual(&this, "putAll", "(Ljava/util/Map;)V", (map,)).await?;

        Ok(())
    }

    async fn contains(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
        tracing::debug!("java.util.Hashtable::contains({this:?}, {value:?})");
        jvm.invoke_virtual(&this, "containsValue", "(Ljava/lang/Object;)Z", (value,)).await
    }

    async fn keys(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::keys({this:?})");

        let snapshot = Self::keys_snapshot(jvm, &this).await?;
        Ok(jvm
            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
            .await?
            .into())
    }

    async fn elements(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::elements({this:?})");

        let snapshot = Self::values_snapshot(jvm, &this).await?;
        Ok(jvm
            .new_class("java/util/Hashtable$Enumerator", "([Ljava/lang/Object;)V", (snapshot,))
            .await?
            .into())
    }

    async fn size(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
        tracing::debug!("java.util.Hashtable::size({this:?})");

        jvm.get_field(&this, "count", "I").await
    }

    async fn is_empty(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
        tracing::debug!("java.util.Hashtable::isEmpty({this:?})");

        let count: i32 = jvm.get_field(&this, "count", "I").await?;

        Ok(count == 0)
    }

    async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
        tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");

        let key_hash = Self::key_hash(jvm, &key).await?;
        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await? as i32;
        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;

        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
        while !entry.is_null() {
            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
            if entry_hash == key_hash {
                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                if equals {
                    return Ok(true);
                }
            }
            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
        }

        Ok(false)
    }

    async fn contains_value(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: ClassInstanceRef<Object>) -> Result<bool> {
        tracing::debug!("java.util.Hashtable::containsValue({this:?}, {value:?})");

        if value.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
        }

        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await?;
        for bucket_index in 0..table_len {
            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
            while !entry.is_null() {
                let entry_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
                if Self::object_equals(jvm, &value, &entry_value).await? {
                    return Ok(true);
                }

                entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
            }
        }

        Ok(false)
    }

    async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");

        let key_hash = Self::key_hash(jvm, &key).await?;
        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await? as i32;
        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;

        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
        while !entry.is_null() {
            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
            if entry_hash == key_hash {
                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                if equals {
                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
                }
            }
            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
        }

        Ok(None.into())
    }

    async fn remove(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        key: ClassInstanceRef<Object>,
    ) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");

        let key_hash = Self::key_hash(jvm, &key).await?;
        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await? as i32;
        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;

        let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();

        while !entry.is_null() {
            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
            if entry_hash == key_hash {
                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                if equals {
                    let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
                    if prev.is_null() {
                        jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
                    } else {
                        jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?;
                    }

                    let count: i32 = jvm.get_field(&this, "count", "I").await?;
                    jvm.put_field(&mut this, "count", "I", count - 1).await?;

                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
                }
            }
            prev = entry;
            entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?;
        }

        Ok(None.into())
    }

    async fn put(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        key: ClassInstanceRef<Object>,
        value: ClassInstanceRef<Object>,
    ) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");

        if value.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
        }

        let key_hash = Self::key_hash(jvm, &key).await?;
        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await? as i32;
        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;

        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
        while !entry.is_null() {
            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
            if entry_hash == key_hash {
                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                if equals {
                    let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
                    jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
                    return Ok(old_value);
                }
            }
            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
        }

        let count: i32 = jvm.get_field(&this, "count", "I").await?;
        let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;

        if count >= threshold {
            Self::rehash_table(jvm, &mut this).await?;
            table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
            let new_table_len = jvm.array_length(&table).await? as i32;
            let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;

            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
            let new_entry = jvm
                .new_class(
                    "java/util/Hashtable$Entry",
                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
                    (key_hash, key, value, existing),
                )
                .await?;
            jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
        } else {
            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
            let new_entry = jvm
                .new_class(
                    "java/util/Hashtable$Entry",
                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
                    (key_hash, key, value, existing),
                )
                .await?;
            jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
        }

        jvm.put_field(&mut this, "count", "I", count + 1).await?;

        Ok(None.into())
    }

    async fn put_all(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, map: ClassInstanceRef<Object>) -> Result<()> {
        tracing::debug!("java.util.Hashtable::putAll({this:?}, {map:?})");

        if map.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "map").await);
        }
        if this.identity() == map.identity() {
            return Ok(());
        }

        let entry_set: ClassInstanceRef<Object> = jvm.invoke_virtual(&map, "entrySet", "()Ljava/util/Set;", ()).await?;
        let entries: ClassInstanceRef<Array<Object>> = jvm.invoke_virtual(&entry_set, "toArray", "()[Ljava/lang/Object;", ()).await?;
        let count = jvm.array_length(&entries).await?;
        let mut validated = Vec::with_capacity(count);
        for entry in jvm.load_array::<ClassInstanceRef<Object>>(&entries, 0, count).await? {
            let key: ClassInstanceRef<Object> = jvm.invoke_virtual(&entry, "getKey", "()Ljava/lang/Object;", ()).await?;
            let value: ClassInstanceRef<Object> = jvm.invoke_virtual(&entry, "getValue", "()Ljava/lang/Object;", ()).await?;
            if key.is_null() {
                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
            }
            if value.is_null() {
                return Err(jvm.exception("java/lang/NullPointerException", "Hashtable value is null").await);
            }
            validated.push((key, value));
        }

        for (key, value) in validated {
            let _: ClassInstanceRef<Object> = jvm
                .invoke_virtual(&this, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", (key, value))
                .await?;
        }

        Ok(())
    }

    async fn clear(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.util.Hashtable::clear({this:?})");

        let mut table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await?;
        if table_len > 0 {
            let nulls: Vec<ClassInstanceRef<HashtableEntry>> = (0..table_len).map(|_| None.into()).collect();
            jvm.store_array(&mut table, 0, nulls).await?;
        }
        jvm.put_field(&mut this, "count", "I", 0).await?;

        Ok(())
    }

    async fn key_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::keySet({this:?})");

        let key_set = jvm.new_class("java/util/Hashtable$KeySet", "(Ljava/util/Hashtable;)V", (this,)).await?;

        Ok(key_set.into())
    }

    async fn values(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::values({this:?})");

        let values = jvm.new_class("java/util/Hashtable$Values", "(Ljava/util/Hashtable;)V", (this,)).await?;

        Ok(values.into())
    }

    async fn entry_set(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Object>> {
        tracing::debug!("java.util.Hashtable::entrySet({this:?})");

        let entry_set = jvm.new_class("java/util/Hashtable$EntrySet", "(Ljava/util/Hashtable;)V", (this,)).await?;

        Ok(entry_set.into())
    }

    pub(super) async fn keys_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
        Self::snapshot_entries(jvm, this, SnapshotKind::Keys).await
    }

    pub(super) async fn values_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
        Self::snapshot_entries(jvm, this, SnapshotKind::Values).await
    }

    pub(super) async fn entries_snapshot(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<ClassInstanceRef<Array<Object>>> {
        Self::snapshot_entries(jvm, this, SnapshotKind::Entries).await
    }

    pub(super) async fn find_entry(
        jvm: &Jvm,
        this: &ClassInstanceRef<Self>,
        key: &ClassInstanceRef<Object>,
    ) -> Result<ClassInstanceRef<HashtableEntry>> {
        let key_hash = Self::key_hash(jvm, key).await?;
        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await? as i32;
        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;

        let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
        while !entry.is_null() {
            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
            if entry_hash == key_hash {
                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                if equals {
                    return Ok(entry);
                }
            }

            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
        }

        Ok(None.into())
    }

    async fn rehash(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
        tracing::debug!("java.util.Hashtable::rehash({this:?})");
        Self::rehash_table(jvm, &mut this).await
    }

    async fn rehash_table(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
        let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let old_capacity = jvm.array_length(&old_table).await?;
        let new_capacity = old_capacity * 2 + 1;

        let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;

        for i in 0..old_capacity {
            let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
            while !entry.is_null() {
                let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
                let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
                let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;

                let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
                jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?;
                jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;

                entry = next;
            }
        }

        jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?;
        jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32)
            .await?;

        Ok(())
    }

    async fn equals(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, other: ClassInstanceRef<Object>) -> Result<bool> {
        tracing::debug!("java.util.Hashtable::equals({this:?}, {other:?})");

        if !other.is_null() && this.identity() == other.identity() {
            return Ok(true);
        }
        if other.is_null() || !jvm.is_instance(other.as_ref(), "java/util/Map") {
            return Ok(false);
        }

        let count: i32 = jvm.get_field(&this, "count", "I").await?;
        let other_size: i32 = jvm.invoke_virtual(&other, "size", "()I", ()).await?;
        if count != other_size {
            return Ok(false);
        }

        let comparison: Result<bool> = async {
            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
            let table_len = jvm.array_length(&table).await?;
            for bucket_index in 0..table_len {
                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
                while !entry.is_null() {
                    let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
                    let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
                    let other_value: ClassInstanceRef<Object> = jvm
                        .invoke_virtual(&other, "get", "(Ljava/lang/Object;)Ljava/lang/Object;", (key.clone(),))
                        .await?;
                    if value.is_null() {
                        if !other_value.is_null()
                            || !jvm
                                .invoke_virtual::<_, bool>(&other, "containsKey", "(Ljava/lang/Object;)Z", (key,))
                                .await?
                        {
                            return Ok(false);
                        }
                    } else if !jvm
                        .invoke_virtual::<_, bool>(&value, "equals", "(Ljava/lang/Object;)Z", (other_value,))
                        .await?
                    {
                        return Ok(false);
                    }

                    entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
                }
            }

            Ok(true)
        }
        .await;
        match comparison {
            Err(JavaError::JavaException(exception))
                if jvm.is_instance(exception.as_ref(), "java/lang/ClassCastException")
                    || jvm.is_instance(exception.as_ref(), "java/lang/NullPointerException") =>
            {
                Ok(false)
            }
            result => result,
        }
    }

    async fn hash_code(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<i32> {
        tracing::debug!("java.util.Hashtable::hashCode({this:?})");

        let count: i32 = jvm.get_field(&this, "count", "I").await?;
        let load_factor: f32 = jvm.get_field(&this, "loadFactor", "F").await?;
        if count == 0 || load_factor < 0.0 {
            return Ok(0);
        }

        jvm.put_field(&mut this, "loadFactor", "F", -load_factor).await?;
        let result: Result<i32> = async {
            let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
            let table_len = jvm.array_length(&table).await?;
            let mut hash = 0i32;
            for bucket_index in 0..table_len {
                let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
                while !entry.is_null() {
                    hash = hash.wrapping_add(jvm.invoke_virtual::<_, i32>(&entry, "hashCode", "()I", ()).await?);
                    entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
                }
            }

            Ok(hash)
        }
        .await;
        jvm.put_field(&mut this, "loadFactor", "F", load_factor).await?;
        result
    }

    async fn to_string(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
        tracing::debug!("java.util.Hashtable::toString({this:?})");

        let snapshot = Self::entries_snapshot(jvm, &this).await?;
        let count = jvm.array_length(&snapshot).await?;
        let entries: Vec<ClassInstanceRef<Object>> = jvm.load_array(&snapshot, 0, count).await?;
        let mut result = RustString::from("{");
        for (index, entry) in entries.into_iter().enumerate() {
            if index > 0 {
                result.push_str(", ");
            }

            let entry: ClassInstanceRef<HashtableEntry> = ClassInstanceRef::new(entry.instance);
            let key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
            if key.instance.as_ref().unwrap().equals(&**this)? {
                result.push_str("(this Map)");
            } else {
                let text: ClassInstanceRef<String> = jvm.invoke_virtual(&key, "toString", "()Ljava/lang/String;", ()).await?;
                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
            }
            result.push('=');

            let value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
            if value.instance.as_ref().unwrap().equals(&**this)? {
                result.push_str("(this Map)");
            } else {
                let text: ClassInstanceRef<String> = jvm.invoke_virtual(&value, "toString", "()Ljava/lang/String;", ()).await?;
                result.push_str(&JavaLangString::to_rust_string(jvm, &text).await?);
            }
        }
        result.push('}');

        Ok(JavaLangString::from_rust_string(jvm, &result).await?.into())
    }

    async fn load_bucket(
        jvm: &Jvm,
        table: &ClassInstanceRef<Array<HashtableEntry>>,
        bucket_index: usize,
    ) -> Result<ClassInstanceRef<HashtableEntry>> {
        Ok(jvm.load_array(table, bucket_index, 1).await?.remove(0))
    }

    async fn key_hash(jvm: &Jvm, key: &ClassInstanceRef<Object>) -> Result<i32> {
        if key.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "Hashtable key is null").await);
        }

        jvm.invoke_virtual(key, "hashCode", "()I", ()).await
    }

    async fn object_equals(jvm: &Jvm, left: &ClassInstanceRef<Object>, right: &ClassInstanceRef<Object>) -> Result<bool> {
        if left.is_null() {
            return Ok(right.is_null());
        }

        if right.is_null() {
            return Ok(false);
        }

        jvm.invoke_virtual(left, "equals", "(Ljava/lang/Object;)Z", (right.clone(),)).await
    }

    async fn snapshot_entries(jvm: &Jvm, this: &ClassInstanceRef<Self>, kind: SnapshotKind) -> Result<ClassInstanceRef<Array<Object>>> {
        let table: ClassInstanceRef<Array<HashtableEntry>> = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
        let table_len = jvm.array_length(&table).await?;
        let count: i32 = jvm.get_field(this, "count", "I").await?;
        let mut elements: Vec<ClassInstanceRef<Object>> = Vec::with_capacity(count as usize);

        for bucket_index in 0..table_len {
            let mut entry = Self::load_bucket(jvm, &table, bucket_index).await?;
            while !entry.is_null() {
                let element = match kind {
                    SnapshotKind::Keys => jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?,
                    SnapshotKind::Values => jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?,
                    SnapshotKind::Entries => ClassInstanceRef::new(entry.clone().instance),
                };
                elements.push(element);

                entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
            }
        }

        let mut snapshot: ClassInstanceRef<Array<Object>> = jvm.instantiate_array("Ljava/lang/Object;", elements.len()).await?.into();
        if !elements.is_empty() {
            jvm.store_array(&mut snapshot, 0, elements).await?;
        }

        Ok(snapshot)
    }
}

#[derive(Copy, Clone)]
enum SnapshotKind {
    Keys,
    Values,
    Entries,
}