/*
 * Copyright (c) 2023, Matthew Olsson <mattco@serenityos.org>
 * Copyright (c) 2023-2024, Shannon Booth <shannon@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <LibJS/Runtime/TypedArray.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/ReadableByteStreamControllerPrototype.h>
#include <LibWeb/Streams/AbstractOperations.h>
#include <LibWeb/Streams/ReadableByteStreamController.h>
#include <LibWeb/Streams/ReadableStream.h>
#include <LibWeb/Streams/ReadableStreamBYOBRequest.h>
#include <LibWeb/Streams/ReadableStreamDefaultReader.h>
#include <LibWeb/WebIDL/Buffers.h>

namespace Web::Streams {

JS_DEFINE_ALLOCATOR(ReadableByteStreamController);

// https://streams.spec.whatwg.org/#rbs-controller-desired-size
Optional<double> ReadableByteStreamController::desired_size() const
{
    // 1. Return ! ReadableByteStreamControllerGetDesiredSize(this).
    return readable_byte_stream_controller_get_desired_size(*this);
}

// https://streams.spec.whatwg.org/#rbs-controller-byob-request
JS::GCPtr<ReadableStreamBYOBRequest> ReadableByteStreamController::byob_request()
{
    // 1. Return ! ReadableByteStreamControllerGetBYOBRequest(this).
    return readable_byte_stream_controller_get_byob_request(*this);
}

// https://streams.spec.whatwg.org/#rbs-controller-close
WebIDL::ExceptionOr<void> ReadableByteStreamController::close()
{
    // 1. If this.[[closeRequested]] is true, throw a TypeError exception.
    if (m_close_requested)
        return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Controller is already closed"sv };

    // 2. If this.[[stream]].[[state]] is not "readable", throw a TypeError exception.
    if (m_stream->state() != ReadableStream::State::Readable) {
        auto message = m_stream->state() == ReadableStream::State::Closed ? "Cannot close a closed stream"sv : "Cannot close an errored stream"sv;
        return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, message };
    }

    // 3. Perform ? ReadableByteStreamControllerClose(this).
    TRY(readable_byte_stream_controller_close(*this));

    return {};
}

// https://streams.spec.whatwg.org/#rbs-controller-error
void ReadableByteStreamController::error(JS::Value error)
{
    // 1. Perform ! ReadableByteStreamControllerError(this, e).
    readable_byte_stream_controller_error(*this, error);
}

ReadableByteStreamController::ReadableByteStreamController(JS::Realm& realm)
    : Bindings::PlatformObject(realm)
{
}

void ReadableByteStreamController::initialize(JS::Realm& realm)
{
    Base::initialize(realm);
    WEB_SET_PROTOTYPE_FOR_INTERFACE(ReadableByteStreamController);
}

// https://streams.spec.whatwg.org/#rbs-controller-enqueue
WebIDL::ExceptionOr<void> ReadableByteStreamController::enqueue(JS::Handle<WebIDL::ArrayBufferView>& chunk)
{
    // 1. If chunk.[[ByteLength]] is 0, throw a TypeError exception.
    // 2. If chunk.[[ViewedArrayBuffer]].[[ArrayBufferByteLength]] is 0, throw a TypeError exception.
    if (chunk->byte_length() == 0 || chunk->viewed_array_buffer()->byte_length() == 0)
        return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Cannot enqueue chunk with byte length of zero"sv };

    // 3. If this.[[closeRequested]] is true, throw a TypeError exception.
    if (m_close_requested)
        return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Close is requested for controller"sv };

    // 4. If this.[[stream]].[[state]] is not "readable", throw a TypeError exception.
    if (!m_stream->is_readable())
        return WebIDL::SimpleException { WebIDL::SimpleExceptionType::TypeError, "Stream is not readable"sv };

    // 5. Return ? ReadableByteStreamControllerEnqueue(this, chunk).
    return readable_byte_stream_controller_enqueue(*this, chunk->raw_object());
}

// https://streams.spec.whatwg.org/#rbs-controller-private-cancel
JS::NonnullGCPtr<WebIDL::Promise> ReadableByteStreamController::cancel_steps(JS::Value reason)
{
    // 1. Perform ! ReadableByteStreamControllerClearPendingPullIntos(this).
    readable_byte_stream_controller_clear_pending_pull_intos(*this);

    // 2. Perform ! ResetQueue(this).
    reset_queue(*this);

    // 3. Let result be the result of performing this.[[cancelAlgorithm]], passing in reason.
    auto result = m_cancel_algorithm->function()(reason);

    // 4. Perform ! ReadableByteStreamControllerClearAlgorithms(this).
    readable_byte_stream_controller_clear_algorithms(*this);

    // 5. Return result.
    return result;
}

// https://streams.spec.whatwg.org/#rbs-controller-private-pull
void ReadableByteStreamController::pull_steps(JS::NonnullGCPtr<ReadRequest> read_request)
{
    auto& realm = this->realm();

    // 1. Let stream be this.[[stream]].

    // 2. Assert: ! ReadableStreamHasDefaultReader(stream) is true.
    VERIFY(readable_stream_has_default_reader(*m_stream));

    // 3. If this.[[queueTotalSize]] > 0,
    if (m_queue_total_size > 0) {
        // 1. Assert: ! ReadableStreamGetNumReadRequests(stream) is 0.
        VERIFY(readable_stream_get_num_read_requests(*m_stream) == 0);

        // 2. Perform ! ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest).
        readable_byte_stream_controller_fill_read_request_from_queue(*this, read_request);

        // 3. Return.
        return;
    }

    // 4. Let autoAllocateChunkSize be this.[[autoAllocateChunkSize]].

    // 5. If autoAllocateChunkSize is not undefined,
    if (m_auto_allocate_chunk_size.has_value()) {
        // 1. Let buffer be Construct(%ArrayBuffer%, « autoAllocateChunkSize »).
        auto buffer = JS::ArrayBuffer::create(realm, *m_auto_allocate_chunk_size);

        // 2. If buffer is an abrupt completion,
        if (buffer.is_throw_completion()) {
            // 1. Perform readRequest’s error steps, given buffer.[[Value]].
            read_request->on_error(*buffer.throw_completion().value());

            // 2. Return.
            return;
        }

        // 3. Let pullIntoDescriptor be a new pull-into descriptor with buffer buffer.[[Value]], buffer byte length autoAllocateChunkSize, byte offset 0,
        //    byte length autoAllocateChunkSize, bytes filled 0, element size 1, view constructor %Uint8Array%, and reader type "default".
        PullIntoDescriptor pull_into_descriptor {
            .buffer = buffer.release_value(),
            .buffer_byte_length = *m_auto_allocate_chunk_size,
            .byte_offset = 0,
            .byte_length = *m_auto_allocate_chunk_size,
            .bytes_filled = 0,
            .minimum_fill = 1,
            .element_size = 1,
            .view_constructor = *realm.intrinsics().uint8_array_constructor(),
            .reader_type = ReaderType::Default,
        };

        // 4. Append pullIntoDescriptor to this.[[pendingPullIntos]].
        m_pending_pull_intos.append(move(pull_into_descriptor));
    }

    // 6. Perform ! ReadableStreamAddReadRequest(stream, readRequest).
    readable_stream_add_read_request(*m_stream, read_request);

    // 7. Perform ! ReadableByteStreamControllerCallPullIfNeeded(this).
    readable_byte_stream_controller_call_pull_if_needed(*this);
}

// https://streams.spec.whatwg.org/#rbs-controller-private-pull
void ReadableByteStreamController::release_steps()
{
    // 1. If this.[[pendingPullIntos]] is not empty,
    if (!m_pending_pull_intos.is_empty()) {
        // 1. Let firstPendingPullInto be this.[[pendingPullIntos]][0].
        auto first_pending_pull_into = m_pending_pull_intos.first();

        // 2. Set firstPendingPullInto’s reader type to "none".
        first_pending_pull_into.reader_type = ReaderType::None;

        // 3. Set this.[[pendingPullIntos]] to the list « firstPendingPullInto ».
        m_pending_pull_intos.clear();
        m_pending_pull_intos.append(first_pending_pull_into);
    }
}

void ReadableByteStreamController::visit_edges(Cell::Visitor& visitor)
{
    Base::visit_edges(visitor);
    visitor.visit(m_byob_request);
    for (auto const& pending_pull_into : m_pending_pull_intos) {
        visitor.visit(pending_pull_into.buffer);
        visitor.visit(pending_pull_into.view_constructor);
    }
    for (auto const& item : m_queue)
        visitor.visit(item.buffer);
    visitor.visit(m_stream);
    visitor.visit(m_cancel_algorithm);
    visitor.visit(m_pull_algorithm);
}

}