data_output_stream.rs

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

use bytemuck::cast_vec;

use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result};
use jvm_class_proto::JavaMethodProto;
use jvm_types::{ClassAccessFlags, MethodAccessFlags, modified_utf8};

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

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

impl DataOutputStream {
    pub fn as_proto() -> RuntimeClassProto {
        RuntimeClassProto {
            name: "java/io/DataOutputStream",
            parent_class: Some("java/io/FilterOutputStream"),
            interfaces: vec!["java/io/DataOutput"],
            methods: vec![
                JavaMethodProto::new("<init>", "(Ljava/io/OutputStream;)V", Self::init, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("write", "(I)V", Self::write, MethodAccessFlags::PUBLIC | MethodAccessFlags::SYNCHRONIZED),
                JavaMethodProto::new(
                    "writeByte",
                    "(I)V",
                    Self::write_byte,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeBoolean",
                    "(Z)V",
                    Self::write_boolean,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new("writeInt", "(I)V", Self::write_int, MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL),
                JavaMethodProto::new(
                    "writeShort",
                    "(I)V",
                    Self::write_short,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeChar",
                    "(I)V",
                    Self::write_char,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeLong",
                    "(J)V",
                    Self::write_long,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeFloat",
                    "(F)V",
                    Self::write_float,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeDouble",
                    "(D)V",
                    Self::write_double,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeBytes",
                    "(Ljava/lang/String;)V",
                    Self::write_bytes,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeChars",
                    "(Ljava/lang/String;)V",
                    Self::write_chars,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new(
                    "writeUTF",
                    "(Ljava/lang/String;)V",
                    Self::write_utf,
                    MethodAccessFlags::PUBLIC | MethodAccessFlags::FINAL,
                ),
                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
                JavaMethodProto::new("flush", "()V", Self::flush, MethodAccessFlags::PUBLIC),
            ],
            fields: vec![],
            access_flags: ClassAccessFlags::PUBLIC,
        }
    }

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

        let _: () = jvm
            .invoke_special(&this, "java/io/FilterOutputStream", "<init>", "(Ljava/io/OutputStream;)V", (out,))
            .await?;

        Ok(())
    }

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

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (b,)).await?;

        Ok(())
    }

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

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "(I)V", (v,)).await?;

        Ok(())
    }

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

        let _: () = jvm
            .invoke_virtual(&this, "java/io/DataOutputStream", "writeByte", "(I)V", (v as i32,))
            .await?;

        Ok(())
    }

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

        let bytes = (s as i16).to_be_bytes();
        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;

        Ok(())
    }

    async fn write_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: i32) -> Result<()> {
        tracing::debug!("java.io.DataOutputStream::writeChar({this:?}, {value:?})");
        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (value & 0xffff,))
            .await
    }

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

        let bytes = i.to_be_bytes();
        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;

        Ok(())
    }

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

        let bytes = l.to_be_bytes();
        let mut byte_array = jvm.instantiate_array("B", bytes.len() as _).await?;
        jvm.store_array(&mut byte_array, 0, cast_vec::<u8, i8>(bytes.to_vec())).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (byte_array,)).await?;

        Ok(())
    }

    async fn write_float(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f32) -> Result<()> {
        tracing::debug!("java.io.DataOutputStream::writeFloat({this:?}, {value:?})");
        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeInt", "(I)V", (value.to_bits() as i32,))
            .await
    }

    async fn write_double(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, value: f64) -> Result<()> {
        tracing::debug!("java.io.DataOutputStream::writeDouble({this:?}, {value:?})");
        jvm.invoke_virtual(&this, "java/io/DataOutputStream", "writeLong", "(J)V", (value.to_bits() as i64,))
            .await
    }

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

        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
        let length = jvm.array_length(&chars).await?;
        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
        let mut bytes = jvm.instantiate_array("B", chars.len()).await?;
        jvm.store_array(&mut bytes, 0, chars.into_iter().map(|value| value as i8)).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
    }

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

        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
        let length = jvm.array_length(&chars).await?;
        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
        let mut data = Vec::with_capacity(chars.len() * 2);
        for value in chars {
            data.push((value >> 8) as i8);
            data.push(value as i8);
        }

        let mut bytes = jvm.instantiate_array("B", data.len()).await?;
        jvm.store_array(&mut bytes, 0, data).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
    }

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

        let chars: ClassInstanceRef<Array<JavaChar>> = jvm.invoke_virtual(&s, "java/lang/String", "toCharArray", "()[C", ()).await?;
        let length = jvm.array_length(&chars).await?;
        let chars: Vec<JavaChar> = jvm.load_array(&chars, 0, length).await?;
        let data: Vec<i8> = cast_vec(modified_utf8::encode(&chars));

        if data.len() > u16::MAX as usize {
            return Err(jvm.exception("java/io/UTFDataFormatException", "encoded string is too long").await);
        }

        let _: () = jvm
            .invoke_virtual(&this, "java/io/DataOutputStream", "writeShort", "(I)V", (data.len() as i32,))
            .await?;

        let mut bytes = jvm.instantiate_array("B", data.len()).await?;
        jvm.store_array(&mut bytes, 0, data).await?;

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        jvm.invoke_virtual(&out, "java/io/OutputStream", "write", "([B)V", (bytes,)).await
    }

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

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "close", "()V", []).await?;

        Ok(())
    }

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

        let out = jvm.get_field(&this, "java/io/DataOutputStream", "out", "Ljava/io/OutputStream;").await?;
        let _: () = jvm.invoke_virtual(&out, "java/io/OutputStream", "flush", "()V", []).await?;

        Ok(())
    }
}