<!DOCTYPE html>
<html>
<head>
<script src="../../resources/js-test-pre.js"></script>
<script src="../js/webgpu-functions.js"></script>
</head>
<body>
<script>
const shaderSource = `
void fill(thread int[] array, int value) {
    for (uint i = 0; i < array.length; i++) {
        array[i] = value;
    }
}

[numthreads(1, 1, 1)]
compute void computeShader(device int[] buffer : register(u0), float3 threadID : SV_DispatchThreadID) {
    int[42] array;
    if (array.length != 42)
        return;
    for (uint i = 0; i < array.length; ++i) {
        if (array[i] != 0)
            return;
    }

    array[0] = 517;
    if (array[0] != 517)
        return;

    thread int[] arrayPtr = @array;
    if (arrayPtr.length != 42)
        return;

    int[42] array2;
    array2 = array;
    if (array2.length != 42)
        return;
    if (array2[0] != 517)
        return;

    fill(arrayPtr, 1337);
    for (uint i = 0; i < arrayPtr.length; ++i) {
        if (arrayPtr[i] != 1337)
            return;
        if (array[i] != 1337)
            return;
    }

    if (array2[0] != 517)
        return;
    if (array2.length != 42)
        return;
    for (uint i = 1; i < array2.length; ++i) {
        if (array2[i] != 0)
            return;
    }

    buffer[0] = 1;
}
`;
async function start(device) {
    const shaderModule = device.createShaderModule({code: shaderSource});
    const computeStage = {module: shaderModule, entryPoint: "computeShader"};

    const bindGroupLayoutDescriptor = {bindings: [{binding: 0, visibility: 7, type: "storage-buffer"}]};
    const bindGroupLayout = device.createBindGroupLayout(bindGroupLayoutDescriptor);
    const pipelineLayoutDescriptor = {bindGroupLayouts: [bindGroupLayout]};
    const pipelineLayout = device.createPipelineLayout(pipelineLayoutDescriptor);

    const computePipelineDescriptor = {computeStage, layout: pipelineLayout};
    const computePipeline = device.createComputePipeline(computePipelineDescriptor);

    const size = Int32Array.BYTES_PER_ELEMENT * 1;

    const bufferDescriptor = {size, usage: GPUBufferUsage.MAP_WRITE | GPUBufferUsage.COPY_SRC};
    const buffer = device.createBuffer(bufferDescriptor);
    const bufferArrayBuffer = await buffer.mapWriteAsync();
    const bufferFloat32Array = new Int32Array(bufferArrayBuffer);
    bufferFloat32Array[0] = 0;
    buffer.unmap();

    const resultsBufferDescriptor = {size, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ};
    const resultsBuffer = device.createBuffer(resultsBufferDescriptor);

    const bufferBinding = {buffer: resultsBuffer, size};
    const bindGroupBinding = {binding: 0, resource: bufferBinding};
    const bindGroupDescriptor = {layout: bindGroupLayout, bindings: [bindGroupBinding]};
    const bindGroup = device.createBindGroup(bindGroupDescriptor);

    const commandEncoder = device.createCommandEncoder(); // {}
    commandEncoder.copyBufferToBuffer(buffer, 0, resultsBuffer, 0, size);
    const computePassEncoder = commandEncoder.beginComputePass();
    computePassEncoder.setPipeline(computePipeline);
    computePassEncoder.setBindGroup(0, bindGroup);
    computePassEncoder.dispatch(1, 1, 1);
    computePassEncoder.endPass();
    const commandBuffer = commandEncoder.finish();
    device.getQueue().submit([commandBuffer]);

    const resultsArrayBuffer = await resultsBuffer.mapReadAsync();
    let resultsInt32Array = new Int32Array(resultsArrayBuffer);
    if (resultsInt32Array[0] === 1)
        testPassed("");
    else
        testFailed("");
    resultsBuffer.unmap();
}
window.jsTestIsAsync = true;
getBasicDevice().then(function(device) {
    start(device).then(function() {
        finishJSTest();
    }, function() {
        testFailed("");
        finishJSTest();
    });
}, function() {
    testPassed("");
    finishJSTest();
});
</script>
<script src="../../resources/js-test-post.js"></script>
</body>
</html>