input_stream_reader.rs

use core::cmp::min;

use alloc::{vec, vec::Vec};

use bytemuck::{cast_slice, cast_vec};

use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};

use crate::{
    RuntimeClassProto, RuntimeContext,
    charset::Charset,
    classes::java::{io::InputStream, lang::System},
};

const BUF_SIZE: usize = 10;

// class java.io.InputStreamReader
pub struct InputStreamReader;

impl InputStreamReader {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/io/InputStreamReader",
            parent_class: Some("java/io/Reader"),
            interfaces: vec![],
            methods: vec![
                JavaMethodProto::new("<init>", "(Ljava/io/InputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new(
                    "<init>",
                    "(Ljava/io/InputStream;Ljava/lang/String;)V",
                    Self::init_with_charset,
                    MethodAccessFlags::PUBLIC,
                ),
                JavaMethodProto::new("read", "([CII)I", Self::read, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
            ],
            fields: vec![
                JavaFieldProto::new("in", "Ljava/io/InputStream;", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("readBuf", "[B", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("readBufSize", "I", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("writeBuf", "[C", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("writeBufSize", "I", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("charset", "Ljava/lang/String;", FieldAccessFlags::PRIVATE),
                JavaFieldProto::new("endOfInput", "Z", FieldAccessFlags::PRIVATE),
            ],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<InputStream>) -> Result<()> {
        tracing::debug!("java.io.InputStreamReader::<init>({this:?}, {:?})", &r#in);

        // Unlike the (InputStream, String) ctor, JDK's single-argument ctor is not declared to throw
        // UnsupportedEncodingException, so an unusable default encoding must surface at read() instead.
        let charset = System::get_charset(jvm).await?;
        // Canonicalize when we recognize it so the stored charset field holds the canonical name;
        // pass an unknown name through unchanged so read() reports it verbatim.
        let charset_name = Charset::from_name(&charset).map_or(charset.as_str(), |x| x.canonical_name());
        Self::init_fields(jvm, this, r#in, charset_name).await
    }

    async fn init_with_charset(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        this: ClassInstanceRef<Self>,
        r#in: ClassInstanceRef<InputStream>,
        charset: ClassInstanceRef<crate::classes::java::lang::String>,
    ) -> Result<()> {
        tracing::debug!("java.io.InputStreamReader::<init>({this:?}, {in:?}, {charset:?})", in = &r#in);

        if r#in.is_null() || charset.is_null() {
            return Err(jvm.exception("java/lang/NullPointerException", "input or encoding is null").await);
        }

        let charset_name = JavaLangString::to_rust_string(jvm, &charset).await?;
        let charset_name = Charset::resolve(jvm, &charset_name).await?.canonical_name();

        Self::init_fields(jvm, this, r#in, charset_name).await
    }

    async fn init_fields(jvm: &Jvm, mut this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<InputStream>, charset_name: &str) -> Result<()> {
        let _: () = jvm.invoke_special(&this, "java/io/Reader", "<init>", "()V", ()).await?;
        let charset = JavaLangString::from_rust_string(jvm, charset_name).await?;
        jvm.put_field(&mut this, "charset", "Ljava/lang/String;", charset).await?;

        let read_buf = jvm.instantiate_array("B", BUF_SIZE).await?;
        jvm.put_field(&mut this, "readBuf", "[B", read_buf).await?;
        jvm.put_field(&mut this, "readBufSize", "I", 0).await?;

        let write_buf = jvm.instantiate_array("C", BUF_SIZE * 3).await?;
        jvm.put_field(&mut this, "writeBuf", "[C", write_buf).await?;
        jvm.put_field(&mut this, "writeBufSize", "I", 0).await?;
        jvm.put_field(&mut this, "endOfInput", "Z", false).await?;

        jvm.put_field(&mut this, "in", "Ljava/io/InputStream;", r#in).await?;

        Ok(())
    }

    async fn read(
        jvm: &Jvm,
        _: &mut RuntimeContext,
        mut this: ClassInstanceRef<Self>,
        buf: ClassInstanceRef<Array<JavaChar>>,
        offset: i32,
        length: i32,
    ) -> Result<i32> {
        tracing::debug!("java.io.InputStreamReader::read({this:?}, {buf:?}, {offset:?}, {length:?})");

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

        let destination_length = jvm.array_length(&buf).await? as i32;
        if offset < 0 || length < 0 || offset > destination_length - length {
            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "Invalid offset or length").await);
        }
        if length == 0 {
            return Ok(0);
        }

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

        while write_buf_size < length {
            let read_buf: ClassInstanceRef<Array<i8>> = jvm.get_field(&this, "readBuf", "[B").await?;
            let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;

            if read_buf_size < (BUF_SIZE / 2) as _ {
                let bytes_to_read = BUF_SIZE as i32 - read_buf_size;

                let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;

                let temp = jvm.instantiate_array("B", bytes_to_read as _).await?;
                let read: i32 = jvm
                    .invoke_virtual(&r#in, "java/io/InputStream", "read", "([BII)I", (temp.clone(), 0, bytes_to_read))
                    .await?;
                if read != -1 {
                    let _: () = jvm
                        .invoke_static(
                            "java/lang/System",
                            "arraycopy",
                            "(Ljava/lang/Object;ILjava/lang/Object;II)V",
                            (temp, 0, read_buf.clone(), read_buf_size, read),
                        )
                        .await?;
                    jvm.put_field(&mut this, "readBufSize", "I", read_buf_size + read).await?;
                } else {
                    jvm.put_field(&mut this, "endOfInput", "Z", true).await?;
                    if read_buf_size == 0 && write_buf_size == 0 {
                        return Ok(-1);
                    }
                }
            }

            let read_buf_size: i32 = jvm.get_field(&this, "readBufSize", "I").await?;
            let mut read_buf_data = vec![0; read_buf_size as _];
            jvm.array_raw_buffer(&read_buf).await?.read(0, &mut read_buf_data)?;

            let charset_ref = jvm.get_field(&this, "charset", "Ljava/lang/String;").await?;
            let charset = JavaLangString::to_rust_string(jvm, &charset_ref).await?;
            let charset = Charset::resolve(jvm, &charset).await?;
            let mut decoder = charset.new_stream_decoder();

            let read_buf_data: Vec<u8> = cast_vec(read_buf_data);
            let end_of_input: bool = jvm.get_field(&this, "endOfInput", "Z").await?;
            let mut decode_length = read_buf_data.len();
            if !end_of_input {
                decode_length -= charset.bytes_to_hold_back(&read_buf_data);
            }

            let mut decoded = vec![0; BUF_SIZE * 3];
            let (read, wrote) = decoder.decode_to_utf16(&read_buf_data[..decode_length], &mut decoded, end_of_input);

            // advance readBuf
            let _: () = jvm
                .invoke_static(
                    "java/lang/System",
                    "arraycopy",
                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
                    (read_buf.clone(), read as i32, read_buf, 0, (read_buf_size - read as i32)),
                )
                .await?;
            jvm.put_field(&mut this, "readBufSize", "I", read_buf_size - read as i32).await?;

            // add to writeBuf
            let mut write_buf = jvm.get_field(&this, "writeBuf", "[C").await?;
            let buffered_chars: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
            jvm.store_array(
                &mut write_buf,
                buffered_chars as _,
                cast_slice::<u16, JavaChar>(&decoded[..wrote]).to_vec(),
            )
            .await?;
            write_buf_size = buffered_chars + wrote as i32;
            jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size).await?;
            if write_buf_size > 0 {
                break;
            }
        }

        let write_buf: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "writeBuf", "[C").await?;
        let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;

        let to_copy = min(length, write_buf_size);

        let _: () = jvm
            .invoke_static(
                "java/lang/System",
                "arraycopy",
                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
                (write_buf.clone(), 0, buf, offset, to_copy),
            )
            .await?;

        // advance writeBuf
        let _: () = jvm
            .invoke_static(
                "java/lang/System",
                "arraycopy",
                "(Ljava/lang/Object;ILjava/lang/Object;II)V",
                (write_buf.clone(), to_copy, write_buf, 0, write_buf_size - to_copy),
            )
            .await?;
        jvm.put_field(&mut this, "writeBufSize", "I", write_buf_size - to_copy).await?;

        Ok(to_copy)
    }

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

        let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
        let _: () = jvm.invoke_virtual(&r#in, "java/io/InputStream", "close", "()V", ()).await?;

        Ok(())
    }

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

        let write_buf_size: i32 = jvm.get_field(&this, "writeBufSize", "I").await?;
        if write_buf_size > 0 {
            return Ok(true);
        }

        let r#in = jvm.get_field(&this, "in", "Ljava/io/InputStream;").await?;
        let available: i32 = jvm.invoke_virtual(&r#in, "java/io/InputStream", "available", "()I", ()).await?;
        Ok(available > 0)
    }
}