src/arkts/SerializerBase.sts

/*
 * Copyright (c) 2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { float32, float64, int8, int32, int64, int32BitsFromFloat } from "@koalaui/common"
import { pointer, KUint8ArrayPtr } from "./InteropTypes"
import { ResourceId, ResourceHolder } from "./ResourceManager"
import { KBuffer } from "./buffer"
import { NativeBuffer } from "./NativeBuffer"
import { InteropNativeModule } from "./InteropNativeModule"

/**
 * Value representing possible JS runtime object type.
 * Must be synced with "enum RuntimeType" in C++.
 */
export class RuntimeType {
    static UNEXPECTED = -1
    static NUMBER = 1
    static STRING = 2
    static OBJECT = 3
    static BOOLEAN = 4
    static UNDEFINED = 5
    static BIGINT = 6
    static FUNCTION = 7
    static SYMBOL = 8
    static MATERIALIZED = 9
}

/**
 * Value representing object type in serialized data.
 * Must be synced with "enum Tags" in C++.
 */
export class Tags {
    static UNDEFINED = 101
    static INT32 = 102
    static FLOAT32 = 103
    static STRING = 104
    static LENGTH = 105
    static RESOURCE = 106
    static OBJECT = 107
}

export function runtimeType(value: Object|String|number|undefined|null): int32 {
    let type = typeof value
    if (type == "number") return RuntimeType.NUMBER
    if (type == "string") return RuntimeType.STRING
    if (type == "undefined") return RuntimeType.UNDEFINED
    if (type == "object") return RuntimeType.OBJECT
    if (type == "boolean") return RuntimeType.BOOLEAN
    if (type == "bigint") return RuntimeType.BIGINT
    if (type == "function") return RuntimeType.FUNCTION
    if (type == "symbol") return RuntimeType.SYMBOL

    throw new Error(`bug: ${value} is ${type}`)
}

export function registerCallback(value: object): int32 {
    // TODO: fix me!
    return 42
}

function registerMaterialized(value: Object): int32 {
    // TODO: fix me!
    return 42
}

export function isResource(value: Object|undefined): boolean {
    // TODO: fix me!
    return false
}

export function isInstanceOf(className: string, value: Object|undefined): boolean {
    // TODO: fix me!
    return false
}

export interface CallbackResource {
    resourceId: int32
    hold: pointer
    release: pointer
}

/* Serialization extension point */
export abstract class CustomSerializer {
    protected supported: Array<string>
    constructor(supported: Array<string>) {
        this.supported = supported
    }
    supports(kind: string): boolean { return this.supported.includes(kind) }
    abstract serialize(serializer: SerializerBase, value: object, kind: string): void
    next: CustomSerializer | undefined = undefined
}

class DateSerializer extends CustomSerializer {
    constructor() {
        super(Array.of("Date" as string))
    }

    serialize(serializer: SerializerBase, value: object, kind: string): void {
        serializer.writeString((value as Date).toISOString())
    }
}
SerializerBase.registerCustomSerializer(new DateSerializer())

export class SerializerBase {
    private position = 0
    private buffer: KBuffer

    private static customSerializers: CustomSerializer | undefined = new DateSerializer()
    static registerCustomSerializer(serializer: CustomSerializer) {
        if (SerializerBase.customSerializers == undefined) {
            SerializerBase.customSerializers = serializer
        } else {
            let current = SerializerBase.customSerializers
            while (current!.next != undefined) {
                current = current!.next
            }
            current!.next = serializer
        }
    }

    resetCurrentPosition(): void { this.position = 0 }

    constructor() {
        this.buffer = new KBuffer(96)
    }
    public release() {
        this.releaseResources()
        this.position = 0
    }
    asArray(): KUint8ArrayPtr {
        return this.buffer.buffer
    }
    length(): int32 {
        return this.position
    }
    currentPosition(): int32 { return this.position }
    private checkCapacity(value: int32) {
        if (value < 1) {
            throw new Error(`${value} is less than 1`)
        }
        let buffSize = this.buffer.length
        if (this.position > buffSize - value) {
            const minSize = this.position + value
            const resizedSize = Math.max(minSize, Math.round(3 * buffSize / 2))
            let resizedBuffer = new KBuffer(resizedSize as int32)
            for (let i = 0; i < this.buffer.length; i++) {
                resizedBuffer.set(i, this.buffer.get(i))
            }
            this.buffer = resizedBuffer
        }
    }
    private heldResources: Array<ResourceId> = new Array<ResourceId>()
    holdAndWriteCallback(callback: object, hold: pointer = 0, release: pointer = 0, call: pointer = 0, callSync: pointer = 0): ResourceId {
        const resourceId = ResourceHolder.instance().registerAndHold(callback)
        this.heldResources.push(resourceId)
        this.writeInt32(resourceId)
        this.writePointer(hold)
        this.writePointer(release)
        this.writePointer(call)
        this.writePointer(callSync)
        return resourceId
    }
    holdAndWriteCallbackForPromiseVoid(hold: pointer = 0, release: pointer = 0, call: pointer = 0): [Promise<void>, ResourceId] {
        let resourceId: ResourceId
        const promise = new Promise<void>((resolve: (value: PromiseLike<void>) => void, reject: (err: Object|null|undefined) => void) => {
            const callback = (err: string[]|undefined) => {
                if (err !== undefined)
                    reject(err!)
                else
                    resolve(Promise.resolve())
            }
            resourceId = this.holdAndWriteCallback(callback, hold, release, call)
        })
        return [promise, resourceId]
    }
    holdAndWriteCallbackForPromise<T>(hold: pointer = 0, release: pointer = 0, call: pointer = 0): [Promise<T>, ResourceId] {
        let resourceId: ResourceId
        const promise = new Promise<T>((resolve: (value: T|PromiseLike<T>) => void, reject: (err: Object|null|undefined) => void) => {
            const callback = (value: T|undefined, err: string[]|undefined) => {
                if (err !== undefined)
                    reject(err!)
                else
                    resolve(value!)
            }
            resourceId = this.holdAndWriteCallback(callback, hold, release, call)
        })
        return [promise, resourceId]
    }
    writeCallbackResource(resource: CallbackResource) {
        this.writeInt32(resource.resourceId)
        this.writePointer(resource.hold)
        this.writePointer(resource.release)
    }
    writeResource(resource: object) {
        const resourceId = ResourceHolder.instance().registerAndHold(resource)
        this.heldResources.push(resourceId)
        this.writeInt32(resourceId)
    }
    private releaseResources() {
        for (const resourceId of this.heldResources)
            InteropNativeModule._ReleaseCallbackResource(resourceId)
        // todo think about effective array clearing/pushing
        this.heldResources = new Array<ResourceId>()
    }
    writeCustomObject(kind: string, value: object) {
        let current = SerializerBase.customSerializers
        while (current) {
            if (current!.supports(kind)) {
                current!.serialize(this, value, kind)
                return
            }
            current = current!.next
        }
        // console.log(`Unsupported custom serialization for ${kind}, write undefined`)
        this.writeInt8(Tags.UNDEFINED as int32)
    }
    writeFunction(value: Object) {
        this.writeInt32(registerCallback(value))
    }
    writeTag(tag: int32): void {
        this.buffer.set(this.position, tag as int8)
        this.position++
    }
    writeNumber(value: number|undefined) {
        this.checkCapacity(5)
        if (value == undefined) {
            this.writeTag(Tags.UNDEFINED)
            this.position++
            return
        }
        if ((value as float64) == Math.round(value)) {
            this.writeTag(Tags.INT32)
            this.writeInt32(value as int32)
            return
        } else {
            this.writeTag(Tags.FLOAT32)
            this.writeFloat32(value as float32)
        }
    }
    writeInt8(value: int32) {
        this.checkCapacity(1)
        this.buffer.set(this.position, value as int8)
        this.position += 1
    }
    private setInt32(position: int32, value: int32): void {
        this.buffer.set(position + 0, ((value      ) & 0xff) as int8)
        this.buffer.set(position + 1, ((value >>  8) & 0xff) as int8)
        this.buffer.set(position + 2, ((value >> 16) & 0xff) as int8)
        this.buffer.set(position + 3, ((value >> 24) & 0xff) as int8)
    }
    writeInt32(value: int32) {
        this.checkCapacity(4)
        this.setInt32(this.position, value)
        this.position += 4
    }
    writeInt64(value: int64) {
        this.checkCapacity(8)
        this.buffer.set(this.position + 0, ((value      ) & 0xff) as int8)
        this.buffer.set(this.position + 1, ((value >>  8) & 0xff) as int8)
        this.buffer.set(this.position + 2, ((value >> 16) & 0xff) as int8)
        this.buffer.set(this.position + 3, ((value >> 24) & 0xff) as int8)
        this.buffer.set(this.position + 4, ((value >> 32) & 0xff) as int8)
        this.buffer.set(this.position + 5, ((value >> 40) & 0xff) as int8)
        this.buffer.set(this.position + 6, ((value >> 48) & 0xff) as int8)
        this.buffer.set(this.position + 7, ((value >> 56) & 0xff) as int8)
        this.position += 8
    }
    writeFloat32(value: float32) {
        let bits = int32BitsFromFloat(value)
        // TODO: this is wrong!
        this.checkCapacity(4)
        this.buffer.set(this.position + 0, ((bits      ) & 0xff) as int8)
        this.buffer.set(this.position + 1, ((bits >>  8) & 0xff) as int8)
        this.buffer.set(this.position + 2, ((bits >> 16) & 0xff) as int8)
        this.buffer.set(this.position + 3, ((bits >> 24) & 0xff) as int8)
        this.position += 4
    }
    writePointer(value: pointer) {
        if (typeof value === "bigint")
            // todo where it is possible to be called from?
            throw new Error("Not implemented")
        this.writeInt64(value)
    }
    writeBoolean(value: boolean|undefined) {
        this.checkCapacity(1)
        if (value == undefined) {
            this.buffer.set(this.position, RuntimeType.UNDEFINED as int32 as int8)
        } else {
            this.buffer.set(this.position, (value ? 1 : 0) as int8)
        }
        this.position++
    }
    writeMaterialized(value: Object) {
        this.writePointer(registerMaterialized(value))
    }
    writeString(value: string) {
        this.checkCapacity((4 + value.length * 4 + 1) as int32) // length, data
        let encodedLength = InteropNativeModule._ManagedStringWrite(value, this.asArray(), this.position + 4)
        this.setInt32(this.position, encodedLength)
        this.position += encodedLength + 4
    }
    //TODO: Needs to be implemented
    writeBuffer(value: NativeBuffer) {
        this.writeCallbackResource({
            resourceId: value.resourceId,
            hold: value.hold,
            release: value.release
        })
        this.writePointer(value.data)
        this.writeInt64(value.length as int64)
    }
}