import { BlobReader } from "./BlobReader"

/** 把一个 Blob 混淆，二进制进行异或运算
 * 这仅仅是简单的混淆处理，不是加密，仅仅为了在某些场合让数据不被简单的识别
 *
 * @param blob 要混淆的 Blob
 * @param KEY 混淆的密钥，即异或的值，默认为 0xFF 即反转字节
 */
export async function obfuscateBlob(blob: Blob, KEY = 0xff) {
    let arrayBuffer = await BlobReader.getArrayBuffer(blob)
    let rawDataLen = arrayBuffer.byteLength
    let rawData = new DataView(arrayBuffer)
    let newData = new DataView(new ArrayBuffer(rawDataLen))

    for (let i = 0; i < rawDataLen; i++) {
        let byte = rawData.getUint8(i)
        let reversedByte = byte ^ KEY
        newData.setUint8(i, reversedByte)
    }

    return new Blob([newData.buffer], { type: blob.type })
}

/** 把一个经 `obfuscateBlob` 混淆过 Blob 还原 */
export async function unObfuscateBlob(blob: Blob, KEY = 0xff) {
    blob.stream
    return obfuscateBlob(blob, KEY)
}

/** 把一个 ReadableStream 混淆，二进制进行异或运算
 * 对于 obfuscateBlob 不能方便处理的大尺寸文件，可以用此方法 */
export async function obfuscateStream(stream: ReadableStream, KEY = 0xff) {
    const transformer = {
        transform(chunk: any[], controller: { enqueue: (arg0: Uint8Array) => void }) {
            const obfuscatedChunk = new Uint8Array(chunk.length)
            for (let i = 0; i < chunk.length; i++) {
                obfuscatedChunk[i] = chunk[i] ^ KEY
            }
            controller.enqueue(obfuscatedChunk)
        },
    }

    return stream.pipeThrough(new TransformStream(transformer))
}

/** 把一个经 `obfuscateStream` 混淆过的 ReadableStream 还原 */
export async function unObfuscateStream(stream: ReadableStream, KEY = 0xff) {
    return obfuscateStream(stream, KEY)
}