/*
 * Copyright (c) 2020-2021, the SerenityOS developers.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/StringBuilder.h>
#include <AK/Utf8View.h>
#include <LibLocale/Segmenter.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Position.h>
#include <LibWeb/DOM/Range.h>
#include <LibWeb/DOM/Text.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/Layout/Viewport.h>
#include <LibWeb/Page/EditEventHandler.h>

namespace Web {

void EditEventHandler::handle_delete_character_after(JS::NonnullGCPtr<DOM::Document> document, JS::NonnullGCPtr<DOM::Position> cursor_position)
{
    auto& node = verify_cast<DOM::Text>(*cursor_position->node());
    auto& text = node.data();

    auto next_offset = node.grapheme_segmenter().next_boundary(cursor_position->offset());
    if (!next_offset.has_value()) {
        // FIXME: Move to the next node and delete the first character there.
        return;
    }

    StringBuilder builder;
    builder.append(text.bytes_as_string_view().substring_view(0, cursor_position->offset()));
    builder.append(text.bytes_as_string_view().substring_view(*next_offset));
    node.set_data(MUST(builder.to_string()));

    document->user_did_edit_document_text({});
}

// This method is quite convoluted but this is necessary to make editing feel intuitive.
void EditEventHandler::handle_delete(JS::NonnullGCPtr<DOM::Document> document, DOM::Range& range)
{
    auto* start = verify_cast<DOM::Text>(range.start_container());
    auto* end = verify_cast<DOM::Text>(range.end_container());

    if (start == end) {
        StringBuilder builder;
        builder.append(start->data().bytes_as_string_view().substring_view(0, range.start_offset()));
        builder.append(end->data().bytes_as_string_view().substring_view(range.end_offset()));

        start->set_data(MUST(builder.to_string()));
    } else {
        // Remove all the nodes that are fully enclosed in the range.
        HashTable<DOM::Node*> queued_for_deletion;
        for (auto* node = start->next_in_pre_order(); node; node = node->next_in_pre_order()) {
            if (node == end)
                break;

            queued_for_deletion.set(node);
        }
        for (auto* parent = start->parent(); parent; parent = parent->parent())
            queued_for_deletion.remove(parent);
        for (auto* parent = end->parent(); parent; parent = parent->parent())
            queued_for_deletion.remove(parent);
        for (auto* node : queued_for_deletion)
            node->remove();

        // Join the parent nodes of start and end.
        DOM::Node *insert_after = start, *remove_from = end, *parent_of_end = end->parent();
        while (remove_from) {
            auto* next_sibling = remove_from->next_sibling();

            remove_from->remove();
            insert_after->parent()->insert_before(*remove_from, *insert_after);

            insert_after = remove_from;
            remove_from = next_sibling;
        }
        if (!parent_of_end->has_children()) {
            if (parent_of_end->parent())
                parent_of_end->remove();
        }

        // Join the start and end nodes.
        StringBuilder builder;
        builder.append(start->data().bytes_as_string_view().substring_view(0, range.start_offset()));
        builder.append(end->data().bytes_as_string_view().substring_view(range.end_offset()));

        start->set_data(MUST(builder.to_string()));
        end->remove();
    }

    document->user_did_edit_document_text({});
}

void EditEventHandler::handle_insert(JS::NonnullGCPtr<DOM::Document> document, JS::NonnullGCPtr<DOM::Position> position, u32 code_point)
{
    StringBuilder builder;
    builder.append_code_point(code_point);
    handle_insert(document, position, MUST(builder.to_string()));
}

void EditEventHandler::handle_insert(JS::NonnullGCPtr<DOM::Document> document, JS::NonnullGCPtr<DOM::Position> position, String data)
{
    if (is<DOM::Text>(*position->node())) {
        auto& node = verify_cast<DOM::Text>(*position->node());

        StringBuilder builder;
        builder.append(node.data().bytes_as_string_view().substring_view(0, position->offset()));
        builder.append(data);
        builder.append(node.data().bytes_as_string_view().substring_view(position->offset()));

        // Cut string by max length
        // FIXME: Cut by UTF-16 code units instead of raw bytes
        if (auto max_length = node.max_length(); max_length.has_value() && builder.string_view().length() > *max_length) {
            node.set_data(MUST(String::from_utf8(builder.string_view().substring_view(0, *max_length))));
        } else {
            node.set_data(MUST(builder.to_string()));
        }
        node.invalidate_style(DOM::StyleInvalidationReason::EditingInsertion);
    } else {
        auto& node = *position->node();
        auto& realm = node.realm();
        auto text = realm.heap().allocate<DOM::Text>(realm, node.document(), data);
        MUST(node.append_child(*text));
        position->set_node(text);
        position->set_offset(1);
    }

    document->user_did_edit_document_text({});
}

}