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

#include <AK/Assertions.h>
#include <AK/Base64.h>
#include <AK/ByteBuffer.h>
#include <AK/Time.h>
#include <LibGC/Heap.h>
#include <LibJS/Runtime/Promise.h>
#include <LibJS/Runtime/Realm.h>
#include <LibJS/Runtime/TypedArray.h>
#include <LibTextCodec/Decoder.h>
#include <LibWeb/Bindings/FileReader.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/DOM/Event.h>
#include <LibWeb/DOM/EventTarget.h>
#include <LibWeb/FileAPI/Blob.h>
#include <LibWeb/FileAPI/FileReader.h>
#include <LibWeb/HTML/EventLoop/EventLoop.h>
#include <LibWeb/HTML/EventNames.h>
#include <LibWeb/HTML/Scripting/Agent.h>
#include <LibWeb/HTML/Scripting/TemporaryExecutionContext.h>
#include <LibWeb/MimeSniff/MimeType.h>
#include <LibWeb/Platform/EventLoopPlugin.h>
#include <LibWeb/Streams/ReadableStream.h>
#include <LibWeb/Streams/ReadableStreamDefaultReader.h>
#include <LibWeb/WebIDL/DOMException.h>
#include <LibWeb/WebIDL/ExceptionOr.h>
#include <LibWeb/WebIDL/Promise.h>

namespace Web::FileAPI {

struct ReadOperationState final : public JS::Cell {
    GC_CELL(ReadOperationState, JS::Cell);
    GC_DECLARE_ALLOCATOR(ReadOperationState);

    explicit ReadOperationState(GC::Ref<Streams::ReadableStreamDefaultReader> reader, ByteBuffer bytes, bool is_first_chunk)
        : reader(reader)
        , bytes(move(bytes))
        , is_first_chunk(is_first_chunk)
    {
    }

    virtual void visit_edges(JS::Cell::Visitor& visitor) override
    {
        Base::visit_edges(visitor);
        visitor.visit(reader);
        visitor.visit(process_next_chunk);
    }

    GC::Ref<Streams::ReadableStreamDefaultReader> reader;
    GC::Ptr<GC::Function<void(GC::Ref<WebIDL::Promise>)>> process_next_chunk;
    ByteBuffer bytes;
    bool is_first_chunk { true };
    Optional<MonotonicTime> progress_timer;
};

GC_DEFINE_ALLOCATOR(ReadOperationState);
GC_DEFINE_ALLOCATOR(FileReader);

FileReader::~FileReader() = default;

FileReader::FileReader(JS::Realm& realm)
    : DOM::EventTarget(realm)
{
}

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

void FileReader::visit_edges(JS::Cell::Visitor& visitor)
{
    Base::visit_edges(visitor);
    visitor.visit(m_error);
    m_result.visit(
        [&](GC::Ref<JS::ArrayBuffer> const& array_buffer) { visitor.visit(array_buffer); },
        [](auto&) {});
}

GC::Ref<FileReader> FileReader::create(JS::Realm& realm)
{
    return realm.create<FileReader>(realm);
}

GC::Ref<FileReader> FileReader::construct_impl(JS::Realm& realm)
{
    return FileReader::create(realm);
}

// https://w3c.github.io/FileAPI/#blob-package-data
WebIDL::ExceptionOr<FileReader::Result> FileReader::blob_package_data(JS::Realm& realm, ByteBuffer bytes, Type type, Optional<String> const& mime_type, Optional<String> const& encoding_name)
{
    // A Blob has an associated package data algorithm, given bytes, a type, a optional mimeType, and a optional encodingName, which switches on type and runs the associated steps:
    switch (type) {
    case Type::DataURL: {
        // Return bytes as a DataURL [RFC2397] subject to the considerations below:
        // Use mimeType as part of the Data URL if it is available in keeping with the Data URL specification [RFC2397].
        // If mimeType is not available return a Data URL without a media-type. [RFC2397].
        // https://github.com/w3c/FileAPI/issues/104
        auto mime_string = mime_type.has_value() && !mime_type->is_empty() ? mime_type.value() : "application/octet-stream"_string;
        return URL::create_with_data(mime_string, MUST(encode_base64(bytes)), true).to_string();
    }
    case Type::Text: {
        // 1. Let encoding be failure.
        Optional<StringView> encoding;

        // 2. If the encodingName is present, set encoding to the result of getting an encoding from encodingName.
        if (encoding_name.has_value())
            encoding = TextCodec::get_standardized_encoding(encoding_name.value());

        // 3. If encoding is failure, and mimeType is present:
        if (!encoding.has_value() && mime_type.has_value()) {
            // 1. Let type be the result of parse a MIME type given mimeType.
            auto maybe_type = MimeSniff::MimeType::parse(mime_type.value());

            // 2. If type is not failure, set encoding to the result of getting an encoding from type’s parameters["charset"].
            if (maybe_type.has_value()) {
                auto const& type = maybe_type.value();
                auto it = type.parameters().find("charset"sv);
                if (it != type.parameters().end())
                    encoding = TextCodec::get_standardized_encoding(it->value);
            }
        }

        // 4. If encoding is failure, then set encoding to UTF-8.
        // 5. Decode bytes using fallback encoding encoding, and return the result.
        auto decoder = TextCodec::decoder_for(encoding.value_or("UTF-8"sv));
        VERIFY(decoder.has_value());
        return TRY_OR_THROW_OOM(realm.vm(), convert_input_to_utf8_using_given_decoder_unless_there_is_a_byte_order_mark(decoder.value(), bytes));
    }
    case Type::ArrayBuffer:
        // Return a new ArrayBuffer whose contents are bytes.
        return JS::ArrayBuffer::create(realm, move(bytes));
    case Type::BinaryString:
        // Return bytes as a binary string, in which every byte is represented by a code unit of equal value [0..255].
        StringBuilder builder(StringBuilder::Mode::UTF16, bytes.size());
        for (auto byte : bytes.bytes())
            builder.append_code_unit(byte);
        return MUST(builder.utf16_string_view().to_utf8());
    }
    VERIFY_NOT_REACHED();
}

void FileReader::queue_a_task(GC::Ref<GC::Function<void()>> task)
{
    // To implement the requirement of removing queued tasks on an abort we keep track of a list of
    // task IDs which are pending evaluation. This allows an abort to go through the task queue to
    // remove those pending tasks.

    auto wrapper_task = GC::create_function(heap(), [this, task] {
        auto& event_loop = *HTML::relevant_agent(*this).event_loop;
        VERIFY(event_loop.currently_running_task());
        auto& current_task = *event_loop.currently_running_task();

        task->function()();

        m_pending_tasks.remove(current_task.id());
    });

    auto id = HTML::queue_global_task(HTML::Task::Source::FileReading, realm().global_object(), wrapper_task);
    m_pending_tasks.set(id);
}

// https://w3c.github.io/FileAPI/#readOperation
WebIDL::ExceptionOr<void> FileReader::read_operation(Blob& blob, Type type, Optional<String> const& encoding_name)
{
    auto& realm = this->realm();
    auto const blobs_type = blob.type();

    // 1. If fr’s state is "loading", throw an InvalidStateError DOMException.
    if (m_state == State::Loading)
        return WebIDL::InvalidStateError::create(realm, "Read already in progress"_utf16);

    // 2. Set fr’s state to "loading".
    m_state = State::Loading;
    m_is_aborted = false;

    // 3. Set fr’s result to null.
    m_result = {};

    // 4. Set fr’s error to null.
    m_error = {};

    // 5. Let stream be the result of calling get stream on blob.
    auto stream = blob.get_stream();

    // 6. Let reader be the result of getting a reader from stream.
    auto reader = TRY(stream->get_a_reader());

    // 7. Let bytes be an empty byte sequence.
    ByteBuffer bytes;

    // 8. Let chunkPromise be the result of reading a chunk from stream with reader.
    auto chunk_promise = reader->read();

    // 9. Let isFirstChunk be true.
    bool is_first_chunk = true;

    // 10. In parallel, while true:
    auto state = realm.create<ReadOperationState>(reader, move(bytes), is_first_chunk);

    state->process_next_chunk = GC::create_function(heap(), [this, state, &realm, type, encoding_name, blobs_type](GC::Ref<WebIDL::Promise> current_chunk_promise) mutable {
        // 1. Wait for chunkPromise to be fulfilled or rejected.
        WebIDL::react_to_promise(
            current_chunk_promise,
            GC::create_function(realm.heap(), [this, state, &realm, type, encoding_name, blobs_type](JS::Value promise_value) mutable -> WebIDL::ExceptionOr<JS::Value> {
                HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };

                if (m_is_aborted)
                    return JS::js_undefined();

                // 2. If chunkPromise is fulfilled, and isFirstChunk is true, queue a task to fire a progress event called loadstart at fr.
                // NOTE: ISSUE 2 We might change loadstart to be dispatched synchronously, to align with XMLHttpRequest behavior. [Issue #119]
                if (state->is_first_chunk) {
                    queue_a_task(GC::create_function(heap(), [this, &realm]() {
                        dispatch_event(DOM::Event::create(realm, HTML::EventNames::loadstart));
                    }));
                }

                // 3. Set isFirstChunk to false.
                state->is_first_chunk = false;

                VERIFY(promise_value.is_object());
                auto& result = promise_value.as_object();

                auto& vm = realm.vm();
                auto value = MUST(result.get(vm.names.value));
                auto done = MUST(result.get(vm.names.done));

                // 4. If chunkPromise is fulfilled with an object whose done property is false and whose value property is a Uint8Array object, run these steps:
                if (!done.as_bool() && value.is_object() && is<JS::Uint8Array>(value.as_object())) {
                    // 1. Let bs be the byte sequence represented by the Uint8Array object.
                    auto const& byte_sequence = as<JS::Uint8Array>(value.as_object());

                    // 2. Append bs to bytes.
                    state->bytes.append(byte_sequence.data());

                    // 3. If roughly 50ms have passed since these steps were last invoked, queue a task to fire a progress event called progress at fr.
                    auto now = MonotonicTime::now();
                    bool enough_time_passed = !state->progress_timer.has_value() || (now - state->progress_timer.value() >= AK::Duration::from_milliseconds(50));
                    // WPT tests for this and expects no progress event to fire when there isn't any data.
                    // See http://wpt.live/FileAPI/reading-data-section/filereader_events.any.html
                    bool contained_data = byte_sequence.array_length().length() > 0;
                    if (enough_time_passed && contained_data) {
                        queue_a_task(GC::create_function(heap(), [this, &realm]() {
                            dispatch_event(DOM::Event::create(realm, HTML::EventNames::progress));
                        }));
                        state->progress_timer = now;
                    }

                    // 4. Set chunkPromise to the result of reading a chunk from stream with reader.
                    auto next_chunk_promise = state->reader->read();
                    state->process_next_chunk->function()(next_chunk_promise);
                }
                // 5. Otherwise, if chunkPromise is fulfilled with an object whose done property is true, queue a task to run the following steps and abort this algorithm:
                else if (done.as_bool()) {
                    queue_a_task(GC::create_function(heap(), [this, bytes = move(state->bytes), type, &realm, encoding_name, blobs_type]() {
                        // 1. Set fr’s state to "done".
                        m_state = State::Done;

                        // 2. Let result be the result of package data given bytes, type, blob’s type, and encodingName.
                        auto result = blob_package_data(realm, bytes, type, blobs_type, encoding_name);

                        // 3. If package data threw an exception error:
                        if (result.is_error()) {
                            // FIXME: 1. Set fr’s error to error.

                            // 2. Fire a progress event called error at fr.
                            dispatch_event(DOM::Event::create(realm, HTML::EventNames::error));
                        }
                        // 4. Else:
                        else {
                            // 1. Set fr’s result to result.
                            m_result = result.release_value();

                            // 2. Fire a progress event called load at the fr.
                            dispatch_event(DOM::Event::create(realm, HTML::EventNames::load));
                        }

                        // 5. If fr’s state is not "loading", fire a progress event called loadend at the fr.
                        if (m_state != State::Loading)
                            dispatch_event(DOM::Event::create(realm, HTML::EventNames::loadend));

                        // NOTE: Event handler for the load or error events could have started another load, if that happens
                        //       the loadend event for this load is not fired.
                    }));
                }

                return JS::js_undefined();
            }),
            // 6. Otherwise, if chunkPromise is rejected with an error error, queue a task to run the following steps and abort this algorithm:
            GC::create_function(realm.heap(), [this, &realm](JS::Value) -> WebIDL::ExceptionOr<JS::Value> {
                HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
                if (m_is_aborted)
                    return JS::js_undefined();

                queue_a_task(GC::create_function(heap(), [this, &realm]() {
                    // 1. Set fr’s state to "done".
                    m_state = State::Done;

                    // FIXME: 2. Set fr’s error to error.

                    // 3. Fire a progress event called error at fr.
                    dispatch_event(DOM::Event::create(realm, HTML::EventNames::error));

                    // 4. If fr’s state is not "loading", fire a progress event called loadend at fr.
                    if (m_state != State::Loading)
                        dispatch_event(DOM::Event::create(realm, HTML::EventNames::loadend));

                    // NOTE: Event handler for the error event could have started another load, if that happens the
                    //       loadend event for this load is not fired.
                }));

                return JS::js_undefined();
            }));
    });

    HTML::queue_global_task(HTML::Task::Source::FileReading, realm.global_object(), GC::create_function(heap(), [chunk_promise, state, &realm]() mutable {
        HTML::TemporaryExecutionContext execution_context { realm, HTML::TemporaryExecutionContext::CallbacksEnabled::Yes };
        state->process_next_chunk->function()(chunk_promise);
    }));

    return {};
}

// https://w3c.github.io/FileAPI/#dfn-readAsDataURL
WebIDL::ExceptionOr<void> FileReader::read_as_data_url(Blob& blob)
{
    // The readAsDataURL(blob) method, when invoked, must initiate a read operation for blob with DataURL.
    return read_operation(blob, Type::DataURL);
}

// https://w3c.github.io/FileAPI/#dfn-readAsText
WebIDL::ExceptionOr<void> FileReader::read_as_text(Blob& blob, Optional<String> const& encoding)
{
    // The readAsText(blob, encoding) method, when invoked, must initiate a read operation for blob with Text and encoding.
    return read_operation(blob, Type::Text, encoding);
}

// https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
WebIDL::ExceptionOr<void> FileReader::read_as_array_buffer(Blob& blob)
{
    // The readAsArrayBuffer(blob) method, when invoked, must initiate a read operation for blob with ArrayBuffer.
    return read_operation(blob, Type::ArrayBuffer);
}

// https://w3c.github.io/FileAPI/#dfn-readAsBinaryString
WebIDL::ExceptionOr<void> FileReader::read_as_binary_string(Blob& blob)
{
    // The readAsBinaryString(blob) method, when invoked, must initiate a read operation for blob with BinaryString.
    // NOTE: The use of readAsArrayBuffer() is preferred over readAsBinaryString(), which is provided for backwards compatibility.
    return read_operation(blob, Type::BinaryString);
}

// https://w3c.github.io/FileAPI/#dfn-abort
void FileReader::abort()
{
    auto& realm = this->realm();

    // 1. If this's state is "empty" or if this's state is "done" set this's result to null and terminate this algorithm.
    if (m_state == State::Empty || m_state == State::Done) {
        m_result = {};
        return;
    }

    // 2. If this's state is "loading" set this's state to "done" and set this's result to null.
    if (m_state == State::Loading) {
        m_state = State::Done;
        m_result = {};
    }

    // 3. If there are any tasks from this on the file reading task source in an affiliated task queue, then remove those tasks from that task queue.
    auto& event_loop = *HTML::relevant_agent(*this).event_loop;
    event_loop.task_queue().remove_tasks_matching([&](auto const& task) {
        return m_pending_tasks.contains(task.id());
    });
    m_pending_tasks.clear();

    // 4. Terminate the algorithm for the read method being processed.
    m_is_aborted = true;

    // 5. Fire a progress event called abort at this.
    dispatch_event(DOM::Event::create(realm, HTML::EventNames::abort));

    // 6. If this's state is not "loading", fire a progress event called loadend at this.
    if (m_state != State::Loading)
        dispatch_event(DOM::Event::create(realm, HTML::EventNames::loadend));
}

void FileReader::set_onloadstart(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::loadstart, value);
}

WebIDL::CallbackType* FileReader::onloadstart()
{
    return event_handler_attribute(HTML::EventNames::loadstart);
}

void FileReader::set_onprogress(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::progress, value);
}

WebIDL::CallbackType* FileReader::onprogress()
{
    return event_handler_attribute(HTML::EventNames::progress);
}

void FileReader::set_onload(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::load, value);
}

WebIDL::CallbackType* FileReader::onload()
{
    return event_handler_attribute(HTML::EventNames::load);
}

void FileReader::set_onabort(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::abort, value);
}

WebIDL::CallbackType* FileReader::onabort()
{
    return event_handler_attribute(HTML::EventNames::abort);
}

void FileReader::set_onerror(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::error, value);
}

WebIDL::CallbackType* FileReader::onerror()
{
    return event_handler_attribute(HTML::EventNames::error);
}

void FileReader::set_onloadend(WebIDL::CallbackType* value)
{
    set_event_handler_attribute(HTML::EventNames::loadend, value);
}

WebIDL::CallbackType* FileReader::onloadend()
{
    return event_handler_attribute(HTML::EventNames::loadend);
}

}
