/*

 * Copyright (c) 2024, Tim Flynn <trflynn89@serenityos.org>

 *

 * SPDX-License-Identifier: BSD-2-Clause

 */

#include <AK/ScopeGuard.h>

#include <LibWeb/HTML/DragEvent.h>

#include <LibWeb/HTML/EventNames.h>

#include <LibWeb/HTML/HTMLInputElement.h>

#include <LibWeb/HTML/HTMLTextAreaElement.h>

#include <LibWeb/HTML/SelectedFile.h>

#include <LibWeb/MimeSniff/Resource.h>

#include <LibWeb/Page/DragAndDropEventHandler.h>

namespace Web {

void DragAndDropEventHandler::visit_edges(JS::Cell::Visitor& visitor) const

{

    visitor.visit(m_source_node);

    visitor.visit(m_immediate_user_selection);

    visitor.visit(m_current_target_element);

}

// https://html.spec.whatwg.org/multipage/dnd.html#drag-and-drop-processing-model

EventResult DragAndDropEventHandler::handle_drag_start(

    JS::Realm& realm,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers,

    Vector<HTML::SelectedFile> files)

{

    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {

        return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);

    };

    // 1. Determine what is being dragged, as follows:

    //

    //    FIXME: If the drag operation was invoked on a selection, then it is the selection that is being dragged.

    //

    //    FIXME: Otherwise, if the drag operation was invoked on a Document, it is the first element, going up the ancestor chain,

    //           starting at the node that the user tried to drag, that has the IDL attribute draggable set to true. If there is

    //           no such element, then nothing is being dragged; return, the drag-and-drop operation is never started.

    //

    //    Otherwise, the drag operation was invoked outside the user agent's purview. What is being dragged is defined by

    //    the document or application where the drag was started.

    // 2. Create a drag data store. All the DND events fired subsequently by the steps in this section must use this drag

    //    data store.

    m_drag_data_store = HTML::DragDataStore::create();

    // 3. Establish which DOM node is the source node, as follows:

    //

    //    FIXME: If it is a selection that is being dragged, then the source node is the Text node that the user started the

    //           drag on (typically the Text node that the user originally clicked). If the user did not specify a particular

    //           node, for example if the user just told the user agent to begin a drag of "the selection", then the source

    //           node is the first Text node containing a part of the selection.

    //

    //    FIXME: Otherwise, if it is an element that is being dragged, then the source node is the element that is being dragged.

    //

    //    Otherwise, the source node is part of another document or application. When this specification requires that

    //    an event be dispatched at the source node in this case, the user agent must instead follow the platform-specific

    //    conventions relevant to that situation.

    m_source_node = nullptr;

    // FIXME: 4. Determine the list of dragged nodes, as follows:

    //

    //    If it is a selection that is being dragged, then the list of dragged nodes contains, in tree order, every node

    //    that is partially or completely included in the selection (including all their ancestors).

    //

    //    Otherwise, the list of dragged nodes contains only the source node, if any.

    // 5. If it is a selection that is being dragged, then add an item to the drag data store item list, with its

    //    properties set as follows:

    //

    //    The drag data item type string

    //        "text/plain"

    //    The drag data item kind

    //        Text

    //    The actual data

    //        The text of the selection

    //

    //    Otherwise, if any files are being dragged, then add one item per file to the drag data store item list, with

    //    their properties set as follows:

    //

    //    The drag data item type string

    //        The MIME type of the file, if known, or "application/octet-stream" otherwise.

    //    The drag data item kind

    //        File

    //    The actual data

    //        The file's contents and name.

    for (auto& file : files) {

        auto contents = file.take_contents();

        auto mime_type = MimeSniff::Resource::sniff(contents);

        m_drag_data_store->add_item({

            .kind = HTML::DragDataStoreItem::Kind::File,

            .type_string = mime_type.essence(),

            .data = move(contents),

            .file_name = file.name(),

        });

    }

    // FIXME: 6. If the list of dragged nodes is not empty, then extract the microdata from those nodes into a JSON form, and

    //           add one item to the drag data store item list, with its properties set as follows:

    //

    //    The drag data item type string

    //        application/microdata+json

    //    The drag data item kind

    //        Text

    //    The actual data

    //        The resulting JSON string.

    // FIXME: 7. Run the following substeps:

    [&]() {

        // 1. Let urls be « ».

        // 2. For each node in the list of dragged nodes:

        //

        //    If the node is an a element with an href attribute

        //        Add to urls the result of encoding-parsing-and-serializing a URL given the element's href content

        //        attribute's value, relative to the element's node document.

        //    If the node is an img element with a src attribute

        //        Add to urls the result of encoding-parsing-and-serializing a URL given the element's src content

        //        attribute's value, relative to the element's node document.

        // 3. If urls is still empty, then return.

        // 4. Let url string be the result of concatenating the strings in urls, in the order they were added, separated

        //    by a U+000D CARRIAGE RETURN U+000A LINE FEED character pair (CRLF).

        // 5. Add one item to the drag data store item list, with its properties set as follows:

        //

        //    The drag data item type string

        //        text/uri-list

        //    The drag data item kind

        //        Text

        //    The actual data

        //        url string

    }();

    // FIXME: 8. Update the drag data store default feedback as appropriate for the user agent (if the user is dragging the

    //           selection, then the selection would likely be the basis for this feedback; if the user is dragging an element,

    //           then that element's rendering would be used; if the drag began outside the user agent, then the platform

    //           conventions for determining the drag feedback should be used).

    // 9. Fire a DND event named dragstart at the source node.

    auto drag_event = fire_a_drag_and_drop_event(m_source_node, HTML::EventNames::dragstart);

    // If the event is canceled, then the drag-and-drop operation should not occur; return.

    if (drag_event->cancelled()) {

        reset();

        return EventResult::Cancelled;

    }

    // FIXME: 10. Fire a pointer event at the source node named pointercancel, and fire any other follow-up events as

    //            required by Pointer Events.

    // 11. Initiate the drag-and-drop operation in a manner consistent with platform conventions, and as described below.

    //

    //     The drag-and-drop feedback must be generated from the first of the following sources that is available:

    //

    //         1. The drag data store bitmap, if any. In this case, the drag data store hot spot coordinate should be

    //            used as hints for where to put the cursor relative to the resulting image. The values are expressed

    //            as distances in CSS pixels from the left side and from the top side of the image respectively.

    //         2. The drag data store default feedback.

    return EventResult::Handled;

}

// https://html.spec.whatwg.org/multipage/dnd.html#drag-and-drop-processing-model:queue-a-task

EventResult DragAndDropEventHandler::handle_drag_move(

    JS::Realm& realm,

    JS::NonnullGCPtr<DOM::Document> document,

    JS::NonnullGCPtr<DOM::Node> node,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers)

{

    if (!has_ongoing_drag_and_drop_operation())

        return EventResult::Cancelled;

    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {

        return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);

    };

    // FIXME: 1. If the user agent is still performing the previous iteration of the sequence (if any) when the next iteration

    //           becomes due, return for this iteration (effectively "skipping missed frames" of the drag-and-drop operation).

    // 2. Fire a DND event named drag at the source node. If this event is canceled, the user agent must set the current

    //    drag operation to "none" (no drag operation).

    auto drag_event = fire_a_drag_and_drop_event(m_source_node, HTML::EventNames::drag);

    if (drag_event->cancelled())

        m_current_drag_operation = HTML::DataTransferEffect::none;

    // 3. If the drag event was not canceled and the user has not ended the drag-and-drop operation, check the state of

    //    the drag-and-drop operation, as follows:

    if (!drag_event->cancelled()) {

        JS::GCPtr<DOM::Node> previous_target_element = m_current_target_element;

        // 1. If the user is indicating a different immediate user selection than during the last iteration (or if this

        //    is the first iteration), and if this immediate user selection is not the same as the current target element,

        //    then update the current target element as follows:

        if (m_immediate_user_selection != node && node != m_current_target_element) {

            m_immediate_user_selection = node;

            // -> If the new immediate user selection is null

            if (!m_immediate_user_selection) {

                // Set the current target element to null also.

                m_current_target_element = nullptr;

            }

            // FIXME: -> If the new immediate user selection is in a non-DOM document or application

            else if (false) {

                // Set the current target element to the immediate user selection.

                m_current_target_element = m_immediate_user_selection;

            }

            // -> Otherwise

            else {

                // Fire a DND event named dragenter at the immediate user selection.

                auto drag_event = fire_a_drag_and_drop_event(m_immediate_user_selection, HTML::EventNames::dragenter);

                // If the event is canceled, then set the current target element to the immediate user selection.

                if (drag_event->cancelled()) {

                    m_current_target_element = m_immediate_user_selection;

                }

                // Otherwise, run the appropriate step from the following list:

                else {

                    // -> If the immediate user selection is a text control (e.g., textarea, or an input element whose

                    //    type attribute is in the Text state) or an editing host or editable element, and the drag data

                    //    store item list has an item with the drag data item type string "text/plain" and the drag data

                    //    item kind text

                    if (allow_text_drop(*m_immediate_user_selection)) {

                        // Set the current target element to the immediate user selection anyway.

                        m_current_target_element = m_immediate_user_selection;

                    }

                    // -> If the immediate user selection is the body element

                    else if (m_immediate_user_selection == document->body()) {

                        // Leave the current target element unchanged.

                    }

                    // -> Otherwise

                    else {

                        // Fire a DND event named dragenter at the body element, if there is one, or at the Document

                        // object, if not. Then, set the current target element to the body element, regardless of

                        // whether that event was canceled or not.

                        DOM::EventTarget* target = document->body();

                        if (!target)

                            target = document;

                        fire_a_drag_and_drop_event(target, HTML::EventNames::dragenter);

                        m_current_target_element = document->body();

                    }

                }

            }

        }

        // 2. If the previous step caused the current target element to change, and if the previous target element

        //    was not null or a part of a non-DOM document, then fire a DND event named dragleave at the previous

        //    target element, with the new current target element as the specific related target.

        if (previous_target_element && previous_target_element != m_current_target_element)

            fire_a_drag_and_drop_event(previous_target_element, HTML::EventNames::dragleave, m_current_target_element);

        // 3. If the current target element is a DOM element, then fire a DND event named dragover at this current

        //    target element.

        if (m_current_target_element && is<DOM::Element>(*m_current_target_element)) {

            auto drag_event = fire_a_drag_and_drop_event(m_current_target_element, HTML::EventNames::dragover);

            // If the dragover event is not canceled, run the appropriate step from the following list:

            if (!drag_event->cancelled()) {

                // -> If the current target element is a text control (e.g., textarea, or an input element whose type

                //    attribute is in the Text state) or an editing host or editable element, and the drag data store

                //    item list has an item with the drag data item type string "text/plain" and the drag data item kind

                //    text.

                if (allow_text_drop(*m_current_target_element)) {

                    // Set the current drag operation to either "copy" or "move", as appropriate given the platform

                    // conventions.

                    m_current_drag_operation = HTML::DataTransferEffect::copy;

                }

                // -> Otherwise

                else {

                    // Reset the current drag operation to "none".

                    m_current_drag_operation = HTML::DataTransferEffect::none;

                }

            }

            // Otherwise (if the dragover event is canceled), set the current drag operation based on the values of the

            // effectAllowed and dropEffect attributes of the DragEvent object's dataTransfer object as they stood after

            // the event dispatch finished, as per the following table:

            else {

                auto const& effect_allowed = drag_event->data_transfer()->effect_allowed();

                auto const& drop_effect = drag_event->data_transfer()->drop_effect();

                // effectAllowed                                             | dropEffect | Drag operation

                // ---------------------------------------------------------------------------------------

                // "uninitialized", "copy", "copyLink", "copyMove", or "all" | "copy"     | "copy"

                // "uninitialized", "link", "copyLink", "linkMove", or "all" | "link"     | "link"

                // "uninitialized", "move", "copyMove", "linkMove", or "all" | "move"     | "move"

                // Any other case                                            |            | "none"

                using namespace HTML::DataTransferEffect;

                if (effect_allowed.is_one_of(uninitialized, copy, copyLink, copyMove, all) && drop_effect == copy)

                    m_current_drag_operation = copy;

                else if (effect_allowed.is_one_of(uninitialized, link, copyLink, linkMove, all) && drop_effect == link)

                    m_current_drag_operation = link;

                else if (effect_allowed.is_one_of(uninitialized, move, copyMove, linkMove, all) && drop_effect == move)

                    m_current_drag_operation = move;

                else

                    m_current_drag_operation = none;

            }

        }

    }

    // Set 4 continues in handle_drag_end.

    if (drag_event->cancelled())

        return handle_drag_end(realm, Cancelled::Yes, screen_position, page_offset, client_offset, offset, button, buttons, modifiers);

    return EventResult::Handled;

}

EventResult DragAndDropEventHandler::handle_drag_leave(

    JS::Realm& realm,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers)

{

    return handle_drag_end(realm, Cancelled::Yes, screen_position, page_offset, client_offset, offset, button, buttons, modifiers);

}

EventResult DragAndDropEventHandler::handle_drop(

    JS::Realm& realm,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers)

{

    return handle_drag_end(realm, Cancelled::No, screen_position, page_offset, client_offset, offset, button, buttons, modifiers);

}

// https://html.spec.whatwg.org/multipage/dnd.html#drag-and-drop-processing-model:event-dnd-drag-3

EventResult DragAndDropEventHandler::handle_drag_end(

    JS::Realm& realm,

    Cancelled cancelled,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers)

{

    if (!has_ongoing_drag_and_drop_operation())

        return EventResult::Cancelled;

    auto fire_a_drag_and_drop_event = [&](JS::GCPtr<DOM::EventTarget> target, FlyString const& name, JS::GCPtr<DOM::EventTarget> related_target = nullptr) {

        return this->fire_a_drag_and_drop_event(realm, target, name, screen_position, page_offset, client_offset, offset, button, buttons, modifiers, related_target);

    };

    ScopeGuard guard { [&]() { reset(); } };

    // 4. Otherwise, if the user ended the drag-and-drop operation (e.g. by releasing the mouse button in a mouse-driven

    //    drag-and-drop interface), or if the drag event was canceled, then this will be the last iteration. Run the

    //    following steps, then stop the drag-and-drop operation:

    {

        bool dropped = false;

        // 1. If the current drag operation is "none" (no drag operation), or, if the user ended the drag-and-drop

        //    operation by canceling it (e.g. by hitting the Escape key), or if the current target element is null, then

        //    the drag operation failed. Run these substeps:

        if (m_current_drag_operation == HTML::DataTransferEffect::none || cancelled == Cancelled::Yes || !m_current_target_element) {

            // 1. Let dropped be false.

            dropped = false;

            // 2. If the current target element is a DOM element, fire a DND event named dragleave at it; otherwise, if

            //    it is not null, use platform-specific conventions for drag cancelation.

            if (m_current_target_element && is<DOM::Element>(*m_current_target_element)) {

                fire_a_drag_and_drop_event(m_current_target_element, HTML::EventNames::dragleave);

            } else if (m_current_target_element) {

                // FIXME: "use platform-specific conventions for drag cancelation"

            }

            // 3. Set the current drag operation to "none".

            m_current_drag_operation = HTML::DataTransferEffect::none;

        }

        // Otherwise, the drag operation might be a success; run these substeps:

        else {

            JS::GCPtr<HTML::DragEvent> drag_event;

            // 1. Let dropped be true.

            dropped = true;

            // 2. If the current target element is a DOM element, fire a DND event named drop at it; otherwise, use

            //    platform-specific conventions for indicating a drop.

            if (is<DOM::Element>(*m_current_target_element)) {

                drag_event = fire_a_drag_and_drop_event(m_current_target_element, HTML::EventNames::drop);

            } else {

                // FIXME: "use platform-specific conventions for indicating a drop"

            }

            // 3. If the event is canceled, set the current drag operation to the value of the dropEffect attribute of

            //    the DragEvent object's dataTransfer object as it stood after the event dispatch finished.

            if (drag_event && drag_event->cancelled()) {

                m_current_drag_operation = drag_event->data_transfer()->drop_effect();

            }

            // Otherwise, the event is not canceled; perform the event's default action, which depends on the exact

            // target as follows:

            else {

                // -> If the current target element is a text control (e.g., textarea, or an input element whose type

                //    attribute is in the Text state) or an editing host or editable element, and the drag data store

                //    item list has an item with the drag data item type string "text/plain" and the drag data item

                //    kind text

                if (allow_text_drop(*m_current_target_element)) {

                    // FIXME: Insert the actual data of the first item in the drag data store item list to have a drag data item

                    //        type string of "text/plain" and a drag data item kind that is text into the text control or editing

                    //        host or editable element in a manner consistent with platform-specific conventions (e.g. inserting

                    //        it at the current mouse cursor position, or inserting it at the end of the field).

                }

                // -> Otherwise

                else {

                    // Reset the current drag operation to "none".

                    m_current_drag_operation = HTML::DataTransferEffect::none;

                }

            }

        }

        // 2. Fire a DND event named dragend at the source node.

        fire_a_drag_and_drop_event(m_source_node, HTML::EventNames::dragend);

        // 3. Run the appropriate steps from the following list as the default action of the dragend event:

        // -> If dropped is true, the current target element is a text control (see below), the current drag operation

        //    is "move", and the source of the drag-and-drop operation is a selection in the DOM that is entirely

        //    contained within an editing host

        if (false) {

            // FIXME: Delete the selection.

        }

        // -> If dropped is true, the current target element is a text control (see below), the current drag operation

        //    is "move", and the source of the drag-and-drop operation is a selection in a text control

        else if (false) {

            // FIXME: The user agent should delete the dragged selection from the relevant text control.

        }

        // -> If dropped is false or if the current drag operation is "none"

        else if (!dropped || m_current_drag_operation == HTML::DataTransferEffect::none) {

            // The drag was canceled. If the platform conventions dictate that this be represented to the user (e.g. by

            // animating the dragged selection going back to the source of the drag-and-drop operation), then do so.

            return EventResult::Cancelled;

        }

        // -> Otherwise

        else {

            // The event has no default action.

        }

    }

    return EventResult::Handled;

}

// https://html.spec.whatwg.org/multipage/dnd.html#fire-a-dnd-event

JS::NonnullGCPtr<HTML::DragEvent> DragAndDropEventHandler::fire_a_drag_and_drop_event(

    JS::Realm& realm,

    JS::GCPtr<DOM::EventTarget> target,

    FlyString const& name,

    CSSPixelPoint screen_position,

    CSSPixelPoint page_offset,

    CSSPixelPoint client_offset,

    CSSPixelPoint offset,

    unsigned button,

    unsigned buttons,

    unsigned modifiers,

    JS::GCPtr<DOM::EventTarget> related_target)

{

    // NOTE: When the source node is determined above, the spec indicates we must follow platform-specific conventions

    //       for dispatching events at the source node if the source node is an out-of-document object. We currently

    //       handle this by allowing callers to pass a null `target` node. This allows us to execute all state-change

    //       operations in the fire-a-DND-event AO, and simply skip event dispatching for now if the target is null.

    // 1. Let dataDragStoreWasChanged be false.

    bool drag_data_store_was_changed = false;

    // 2. If no specific related target was provided, set related target to null.

    // 3. Let window be the relevant global object of the Document object of the specified target element.

    // NOTE: We defer this until it's needed later, to more easily handle when the target is not an element.

    // 4. If e is dragstart, then set the drag data store mode to the read/write mode and set dataDragStoreWasChanged to true.

    if (name == HTML::EventNames::dragstart) {

        m_drag_data_store->set_mode(HTML::DragDataStore::Mode::ReadWrite);

        drag_data_store_was_changed = true;

    }

    // 5. If e is drop, set the drag data store mode to the read-only mode.

    else if (name == HTML::EventNames::drop) {

        m_drag_data_store->set_mode(HTML::DragDataStore::Mode::ReadOnly);

    }

    // 6. Let dataTransfer be a newly created DataTransfer object associated with the given drag data store.

    auto data_transfer = HTML::DataTransfer::create(realm, *m_drag_data_store);

    // 7. Set the effectAllowed attribute to the drag data store's drag data store allowed effects state.

    data_transfer->set_effect_allowed_internal(m_drag_data_store->allowed_effects_state());

    // 8. Set the dropEffect attribute to "none" if e is dragstart, drag, or dragleave; to the value corresponding to the

    //    current drag operation if e is drop or dragend; and to a value based on the effectAllowed attribute's value and

    //    the drag-and-drop source, as given by the following table, otherwise (i.e. if e is dragenter or dragover):

    if (name.is_one_of(HTML::EventNames::dragstart, HTML::EventNames::drag, HTML::EventNames::dragleave)) {

        data_transfer->set_drop_effect(HTML::DataTransferEffect::none);

    } else if (name.is_one_of(HTML::EventNames::drop, HTML::EventNames::dragend)) {

        data_transfer->set_drop_effect(m_current_drag_operation);

    } else {

        // effectAllowed                                                                     | dropEffect

        // ---------------------------------------------------------------------------------------------------------------------------------------

        // "none"                                                                            | "none"

        // "copy"                                                                            | "copy"

        // "copyLink"                                                                        | "copy", or, if appropriate, "link"

        // "copyMove"                                                                        | "copy", or, if appropriate, "move"

        // "all"                                                                             | "copy", or, if appropriate, either "link" or "move"

        // "link"                                                                            | "link"

        // "linkMove"                                                                        | "link", or, if appropriate, "move"

        // "move"                                                                            | "move"

        // "uninitialized" when what is being dragged is a selection from a text control     | "move", or, if appropriate, either "copy" or "link"

        // "uninitialized" when what is being dragged is a selection                         | "copy", or, if appropriate, either "link" or "move"

        // "uninitialized" when what is being dragged is an a element with an href attribute | "link", or, if appropriate, either "copy" or "move"

        // Any other case                                                                    | "copy", or, if appropriate, either "link" or "move"

        using namespace HTML::DataTransferEffect;

        // clang-format off

        if (data_transfer->effect_allowed() == none)          data_transfer->set_drop_effect(none);

        else if (data_transfer->effect_allowed() == copy)     data_transfer->set_drop_effect(copy);

        else if (data_transfer->effect_allowed() == copyLink) data_transfer->set_drop_effect(copy);

        else if (data_transfer->effect_allowed() == copyMove) data_transfer->set_drop_effect(copy);

        else if (data_transfer->effect_allowed() == all)      data_transfer->set_drop_effect(copy);

        else if (data_transfer->effect_allowed() == link)     data_transfer->set_drop_effect(link);

        else if (data_transfer->effect_allowed() == linkMove) data_transfer->set_drop_effect(link);

        else if (data_transfer->effect_allowed() == move)     data_transfer->set_drop_effect(move);

        // FIXME: Handle "uninitialized" when element drag operations are supported.

        else data_transfer->set_drop_effect(copy);

        // clang-format on

    }

    // 9. Let event be the result of creating an event using DragEvent.

    // FIXME: Implement https://dom.spec.whatwg.org/#concept-event-create

    HTML::DragEventInit event_init {};

    // 10. Initialize event's type attribute to e, its bubbles attribute to true, its view attribute to window, its

    //     relatedTarget attribute to related target, and its dataTransfer attribute to dataTransfer.

    event_init.bubbles = true;

    event_init.related_target = related_target;

    event_init.data_transfer = data_transfer;

    if (target) {

        auto& window = static_cast<HTML::Window&>(HTML::relevant_global_object(*target));

        event_init.view = window;

    }

    //     If e is not dragleave or dragend, then initialize event's cancelable attribute to true.

    if (!name.is_one_of(HTML::EventNames::dragleave, HTML::EventNames::dragend))

        event_init.cancelable = true;

    // 11. Initialize event's mouse and key attributes initialized according to the state of the input devices as they

    //     would be for user interaction events.

    event_init.ctrl_key = (modifiers & UIEvents::Mod_Ctrl) != 0;

    event_init.shift_key = (modifiers & UIEvents::Mod_Shift) != 0;

    event_init.alt_key = (modifiers & UIEvents::Mod_Alt) != 0;

    event_init.meta_key = (modifiers & UIEvents::Mod_Super) != 0;

    event_init.screen_x = screen_position.x().to_double();

    event_init.screen_y = screen_position.y().to_double();

    event_init.client_x = client_offset.x().to_double();

    event_init.client_y = client_offset.y().to_double();

    event_init.button = button;

    event_init.buttons = buttons;

    auto event = HTML::DragEvent::create(realm, name, event_init, page_offset.x().to_double(), page_offset.y().to_double(), offset.x().to_double(), offset.y().to_double());

    // The "create an event" AO in step 9 should set these.

    event->set_is_trusted(true);

    event->set_initialized(true);

    event->set_composed(true);

    // 12. Dispatch event at the specified target element.

    if (target)

        target->dispatch_event(event);

    // 13. Set the drag data store allowed effects state to the current value of dataTransfer's effectAllowed attribute.

    //     (It can only have changed value if e is dragstart.)

    m_drag_data_store->set_allowed_effects_state(data_transfer->effect_allowed());

    // 14. If dataDragStoreWasChanged is true, then set the drag data store mode back to the protected mode.

    if (drag_data_store_was_changed)

        m_drag_data_store->set_mode(HTML::DragDataStore::Mode::Protected);

    // 15. Break the association between dataTransfer and the drag data store.

    data_transfer->disassociate_with_drag_data_store();

    return event;

}

bool DragAndDropEventHandler::allow_text_drop(JS::NonnullGCPtr<DOM::Node> node) const

{

    if (!m_drag_data_store->has_text_item())

        return false;

    if (node->is_editable())

        return true;

    if (is<HTML::HTMLTextAreaElement>(*node))

        return true;

    if (is<HTML::HTMLInputElement>(*node)) {

        auto const& input = static_cast<HTML::HTMLInputElement const&>(*node);

        return input.type_state() == HTML::HTMLInputElement::TypeAttributeState::Text;

    }

    return false;

}

void DragAndDropEventHandler::reset()

{

    // When the drag-and-drop operation has completed, we no longer need the drag data store and its related fields.

    // Clear them, as we currently use the existence of the drag data store to ignore other input events.

    m_drag_data_store.clear();

    m_source_node = nullptr;

    m_immediate_user_selection = nullptr;

    m_current_target_element = nullptr;

    m_current_drag_operation = HTML::DataTransferEffect::none;

}

}