/*
 * Copyright (c) 2026-present, the Ladybird developers.
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#include <AK/Debug.h>
#include <AK/QuickSort.h>
#include <AK/Utf8View.h>
#include <LibDatabase/Database.h>
#include <LibURL/Parser.h>
#include <LibURL/URL.h>
#include <LibWebView/HistoryDebug.h>
#include <LibWebView/HistoryStore.h>

namespace WebView {

static constexpr auto DEFAULT_AUTOCOMPLETE_SUGGESTION_LIMIT = 8uz;
static constexpr size_t MINIMUM_TITLE_AUTOCOMPLETE_QUERY_LENGTH = 3;

static Optional<StringView> url_without_scheme(StringView url)
{
    auto scheme_separator = url.find("://"sv);
    if (!scheme_separator.has_value())
        return {};

    return url.substring_view(*scheme_separator + 3);
}

static StringView autocomplete_searchable_url(StringView url)
{
    auto stripped_url = url_without_scheme(url).value_or(url);
    if (stripped_url.starts_with("www."sv, CaseSensitivity::CaseInsensitive))
        stripped_url = stripped_url.substring_view(4);

    return stripped_url;
}

static StringView autocomplete_url_query(StringView query)
{
    auto stripped_query = url_without_scheme(query).value_or(query);
    if (stripped_query.starts_with("www."sv, CaseSensitivity::CaseInsensitive))
        stripped_query = stripped_query.substring_view(4);

    return stripped_query;
}

static StringView autocomplete_title_query(StringView query)
{
    if (Utf8View { query }.length() < MINIMUM_TITLE_AUTOCOMPLETE_QUERY_LENGTH)
        return {};

    return query;
}

static StringView autocomplete_url_contains_query(StringView query)
{
    // Non-prefix URL matches get noisy very quickly, so only enable them
    // once the user has typed enough to disambiguate path fragments.
    if (Utf8View { query }.length() < MINIMUM_TITLE_AUTOCOMPLETE_QUERY_LENGTH)
        return {};

    return query;
}

static bool matches_query(HistoryEntry const& entry, StringView title_query, StringView url_query)
{
    auto searchable_url = autocomplete_searchable_url(entry.url.bytes_as_string_view());
    if (!url_query.is_empty() && searchable_url.starts_with(url_query, CaseSensitivity::CaseInsensitive))
        return true;

    auto url_contains_query = autocomplete_url_contains_query(url_query);
    if (!url_contains_query.is_empty() && searchable_url.contains(url_contains_query, CaseSensitivity::CaseInsensitive))
        return true;

    return !title_query.is_empty()
        && entry.title.has_value()
        && entry.title->contains(title_query, CaseSensitivity::CaseInsensitive);
}

static u8 match_rank(HistoryEntry const& entry, StringView title_query, StringView url_query)
{
    auto searchable_url = autocomplete_searchable_url(entry.url.bytes_as_string_view());

    if (!url_query.is_empty()) {
        if (searchable_url.equals_ignoring_ascii_case(url_query))
            return 0;
        if (searchable_url.starts_with(url_query, CaseSensitivity::CaseInsensitive))
            return 1;
    }

    if (!title_query.is_empty() && entry.title.has_value() && entry.title->starts_with_bytes(title_query, CaseSensitivity::CaseInsensitive))
        return 2;

    return 3;
}

static void sort_matching_entries(Vector<HistoryEntry const*>& matches, StringView title_query, StringView url_query)
{
    quick_sort(matches, [&](auto const* left, auto const* right) {
        auto left_rank = match_rank(*left, title_query, url_query);
        auto right_rank = match_rank(*right, title_query, url_query);
        if (left_rank != right_rank)
            return left_rank < right_rank;

        if (left->visit_count != right->visit_count)
            return left->visit_count > right->visit_count;

        if (left->last_visited_time != right->last_visited_time)
            return left->last_visited_time > right->last_visited_time;

        return left->url < right->url;
    });
}

[[maybe_unused]] static ByteString log_history_entries(Vector<HistoryEntry> const& entries)
{
    Vector<String> suggestions;
    suggestions.ensure_capacity(entries.size());
    for (auto const& entry : entries)
        suggestions.unchecked_append(entry.url);
    return history_log_suggestions(suggestions);
}

ErrorOr<NonnullOwnPtr<HistoryStore>> HistoryStore::create(Database::Database& database)
{
    if (auto database_path = database.database_path(); database_path.has_value())
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Opening persisted history store at {}", database_path->string());
    else
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Opening memory-backed persisted history store");

    Statements statements {};

    auto create_history_table = TRY(database.prepare_statement(R"#(
        CREATE TABLE IF NOT EXISTS History (
            url TEXT PRIMARY KEY,
            title TEXT NOT NULL,
            favicon TEXT,
            visit_count INTEGER NOT NULL,
            last_visited_time INTEGER NOT NULL
        );
    )#"sv));
    database.execute_statement(create_history_table, {});

    auto create_last_visited_index = TRY(database.prepare_statement(R"#(
        CREATE INDEX IF NOT EXISTS HistoryLastVisitedTimeIndex
        ON History(last_visited_time DESC);
    )#"sv));
    database.execute_statement(create_last_visited_index, {});

    statements.upsert_entry = TRY(database.prepare_statement(R"#(
        INSERT INTO History (url, title, visit_count, last_visited_time)
        VALUES (?, ?, 1, ?)
        ON CONFLICT(url) DO UPDATE SET
            title = CASE
                WHEN excluded.title != '' THEN excluded.title
                ELSE History.title
            END,
            visit_count = History.visit_count + 1,
            last_visited_time = excluded.last_visited_time;
    )#"sv));
    statements.update_title = TRY(database.prepare_statement(R"#(
        UPDATE History
        SET title = ?
        WHERE url = ?;
    )#"sv));
    statements.update_favicon = TRY(database.prepare_statement(R"#(
        UPDATE History
        SET favicon = ?
        WHERE url = ?;
    )#"sv));
    statements.get_entry = TRY(database.prepare_statement(R"#(
        SELECT title, visit_count, last_visited_time, COALESCE(favicon, '')
        FROM History
        WHERE url = ?;
    )#"sv));
    statements.search_entries = TRY(database.prepare_statement(R"#(
        SELECT url, title, visit_count, last_visited_time, COALESCE(favicon, '')
        FROM (
            SELECT
                url,
                title,
                visit_count,
                last_visited_time,
                COALESCE(favicon, '') AS favicon,
                CASE
                    WHEN LOWER(CASE
                        WHEN INSTR(url, '://') > 0 THEN SUBSTR(url, INSTR(url, '://') + 3)
                        ELSE url
                    END) LIKE 'www.%'
                    THEN SUBSTR(CASE
                        WHEN INSTR(url, '://') > 0 THEN SUBSTR(url, INSTR(url, '://') + 3)
                        ELSE url
                    END, 5)
                    ELSE CASE
                        WHEN INSTR(url, '://') > 0 THEN SUBSTR(url, INSTR(url, '://') + 3)
                        ELSE url
                    END
                END AS searchable_url
            FROM History
        )
        WHERE ((?1 != '' AND LOWER(searchable_url) LIKE LOWER(?1) || '%')
            OR (?2 != '' AND INSTR(LOWER(searchable_url), LOWER(?2)) > 0)
            OR (?3 != '' AND INSTR(LOWER(title), LOWER(?3)) > 0))
        ORDER BY
            CASE
                WHEN ?1 != '' AND LOWER(searchable_url) = LOWER(?1) THEN 0
                WHEN ?1 != '' AND LOWER(searchable_url) LIKE LOWER(?1) || '%' THEN 1
                WHEN ?3 != '' AND LOWER(title) LIKE LOWER(?3) || '%' THEN 2
                ELSE 3
            END,
            visit_count DESC,
            last_visited_time DESC,
            url ASC
        LIMIT ?4;
    )#"sv));
    statements.clear_entries = TRY(database.prepare_statement("DELETE FROM History;"sv));
    statements.delete_entries_accessed_since = TRY(database.prepare_statement("DELETE FROM History WHERE last_visited_time >= ?;"sv));

    return adopt_own(*new HistoryStore { adopt_own<StorageImpl>(*new PersistedStorage { database, move(statements) }) });
}

NonnullOwnPtr<HistoryStore> HistoryStore::create()
{
    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Opening transient history store");

    return adopt_own(*new HistoryStore { adopt_own<StorageImpl>(*new TransientStorage {}) });
}

NonnullOwnPtr<HistoryStore> HistoryStore::create_disabled()
{
    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Opening disabled history store");

    return adopt_own(*new HistoryStore { adopt_own<StorageImpl>(*new TransientStorage {}), true });
}

HistoryStore::HistoryStore(NonnullOwnPtr<StorageImpl>&& storage, bool is_disabled)
    : m_storage(move(storage))
    , m_is_disabled(is_disabled)
{
}

HistoryStore::~HistoryStore() = default;

Optional<String> HistoryStore::normalize_url(URL::URL const& url)
{
    if (url.scheme().is_empty()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Skipping history entry without a scheme: {}", url);
        return {};
    }

    if (url.scheme().is_one_of("about"sv, "data"sv)) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Skipping non-browsable history URL: {}", url);
        return {};
    }

    auto normalized_url = url.serialize(URL::ExcludeFragment::Yes);
    if (normalized_url.is_empty()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Skipping history entry with an empty normalized URL: {}", url);
        return {};
    }

    return normalized_url;
}

void HistoryStore::record_visit(URL::URL const& url, Optional<String> title, UnixDateTime visited_at)
{
    if (m_is_disabled)
        return;

    auto normalized_url = normalize_url(url);
    if (!normalized_url.has_value())
        return;

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Recording visit in {} store: url='{}' title='{}' visited_at={}",
        m_storage->name(),
        *normalized_url,
        title.has_value() ? title->bytes_as_string_view() : "<none>"sv,
        visited_at.seconds_since_epoch());

    m_storage->record_visit(*normalized_url, title, visited_at);
}

void HistoryStore::update_title(URL::URL const& url, String const& title)
{
    if (m_is_disabled)
        return;

    if (title.is_empty()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Ignoring empty history title update for {}", url);
        return;
    }

    auto normalized_url = normalize_url(url);
    if (!normalized_url.has_value())
        return;

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Updating history title in {} store: url='{}' title='{}'",
        m_storage->name(),
        *normalized_url,
        title);

    m_storage->update_title(*normalized_url, title);
}

void HistoryStore::update_favicon(URL::URL const& url, String const& favicon_base64_png)
{
    if (favicon_base64_png.is_empty()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Ignoring empty history favicon update for {}", url);
        return;
    }

    auto normalized_url = normalize_url(url);
    if (!normalized_url.has_value())
        return;

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Updating history favicon in {} store: url='{}' bytes={}",
        m_storage->name(),
        *normalized_url,
        favicon_base64_png.bytes().size());

    m_storage->update_favicon(*normalized_url, favicon_base64_png);
}

void HistoryStore::record_closed_tab(URL::URL const& url, UnixDateTime closed_at)
{
    m_recently_closed_entries.empend(RecentlyClosedEntry {
        .urls = { url },
        .was_window = false,
        .active_tab_index = 0,
        .closed_time = closed_at,
    });
}

void HistoryStore::record_closed_window(Vector<URL::URL> urls, size_t active_tab_index, UnixDateTime closed_at)
{
    if (urls.is_empty())
        return;

    m_recently_closed_entries.empend(RecentlyClosedEntry {
        .urls = move(urls),
        .was_window = true,
        .active_tab_index = 0,
        .closed_time = closed_at,
    });

    auto& entry = m_recently_closed_entries.last();
    entry.active_tab_index = active_tab_index < entry.urls.size() ? active_tab_index : entry.urls.size() - 1;
}

bool HistoryStore::has_recently_closed_entries() const
{
    return !m_recently_closed_entries.is_empty();
}

Optional<RecentlyClosedEntry const&> HistoryStore::most_recently_closed_entry() const
{
    if (m_recently_closed_entries.is_empty())
        return {};

    return m_recently_closed_entries.last();
}

Optional<RecentlyClosedEntry> HistoryStore::pop_most_recently_closed_entry()
{
    if (m_recently_closed_entries.is_empty())
        return {};

    return m_recently_closed_entries.take_last();
}

Optional<HistoryEntry> HistoryStore::entry_for_url(URL::URL const& url)
{
    if (m_is_disabled)
        return {};

    auto normalized_url = normalize_url(url);
    if (!normalized_url.has_value())
        return {};

    auto entry = m_storage->entry_for_url(*normalized_url);

    if (entry.has_value()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Found history entry for '{}': title='{}' visits={} last_visited={} has_favicon={}",
            entry->url,
            entry->title.has_value() ? entry->title->bytes_as_string_view() : "<none>"sv,
            entry->visit_count,
            entry->last_visited_time.seconds_since_epoch(),
            entry->favicon_base64_png.has_value());
    } else {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] No history entry found for '{}'", *normalized_url);
    }

    return entry;
}

Vector<HistoryEntry> HistoryStore::autocomplete_entries(StringView query, size_t limit)
{
    if (m_is_disabled)
        return {};

    auto trimmed_query = query.trim_whitespace();
    if (trimmed_query.is_empty()) {
        dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] History autocomplete query is empty after trimming");
        return {};
    }

    auto title_query = autocomplete_title_query(trimmed_query);
    auto url_query = autocomplete_url_query(trimmed_query);

    auto entries = m_storage->autocomplete_entries(title_query, url_query, limit);

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] {} history autocomplete suggestions for '{}' (title_query='{}', url_query='{}', limit={}): {}",
        m_storage->name(),
        trimmed_query,
        title_query,
        url_query,
        limit,
        log_history_entries(entries));

    return entries;
}

void HistoryStore::clear()
{
    if (m_is_disabled)
        return;

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Clearing {} history store", m_storage->name());
    m_storage->clear();
    m_recently_closed_entries.clear();
}

void HistoryStore::remove_entries_accessed_since(UnixDateTime since)
{
    if (m_is_disabled)
        return;

    dbgln_if(WEBVIEW_HISTORY_DEBUG, "[History] Removing {} history entries accessed since {}",
        m_storage->name(),
        since.seconds_since_epoch());
    m_storage->remove_entries_accessed_since(since);
    m_recently_closed_entries.remove_all_matching([&](auto const& entry) {
        return entry.closed_time >= since;
    });
}

void HistoryStore::TransientStorage::record_visit(String const& url, Optional<String> const& title, UnixDateTime visited_at)
{
    auto entry = m_entries.find(url);
    if (entry == m_entries.end()) {
        auto new_entry = HistoryEntry {
            .url = url,
            .title = move(title),
            .favicon_base64_png = {},
            .visit_count = 1,
            .last_visited_time = visited_at,
        };
        m_entries.set(
            move(url),
            move(new_entry));
        return;
    }

    entry->value.visit_count++;
    entry->value.last_visited_time = visited_at;
    if (title.has_value() && !title->is_empty())
        entry->value.title = move(title);
}

void HistoryStore::TransientStorage::update_title(String const& url, String const& title)
{
    auto entry = m_entries.find(url);
    if (entry == m_entries.end())
        return;

    entry->value.title = move(title);
}

void HistoryStore::TransientStorage::update_favicon(String const& url, String const& favicon_base64_png)
{
    auto entry = m_entries.find(url);
    if (entry == m_entries.end())
        return;

    entry->value.favicon_base64_png = move(favicon_base64_png);
}

Optional<HistoryEntry> HistoryStore::TransientStorage::entry_for_url(String const& url)
{
    auto entry = m_entries.get(url);
    if (!entry.has_value())
        return {};

    return *entry;
}

Vector<HistoryEntry> HistoryStore::TransientStorage::autocomplete_entries(StringView title_query, StringView url_query, size_t limit)
{
    Vector<HistoryEntry const*> matches;

    for (auto const& entry : m_entries) {
        if (matches_query(entry.value, title_query, url_query))
            matches.append(&entry.value);
    }

    sort_matching_entries(matches, title_query, url_query);

    Vector<HistoryEntry> entries;
    entries.ensure_capacity(min(limit, matches.size()));

    for (size_t i = 0; i < matches.size() && i < limit; ++i)
        entries.unchecked_append(*matches[i]);

    return entries;
}

void HistoryStore::TransientStorage::clear()
{
    m_entries.clear();
}

void HistoryStore::TransientStorage::remove_entries_accessed_since(UnixDateTime since)
{
    m_entries.remove_all_matching([&](auto const&, auto const& entry) {
        return entry.last_visited_time >= since;
    });
}

HistoryStore::PersistedStorage::PersistedStorage(Database::Database& database, Statements&& statements)
    : m_database(database)
    , m_statements(move(statements))
{
}

HistoryStore::PersistedStorage::~PersistedStorage() = default;

void HistoryStore::PersistedStorage::record_visit(String const& url, Optional<String> const& title, UnixDateTime visited_at)
{
    m_database.execute_statement(
        m_statements.upsert_entry,
        {},
        url,
        title.value_or(String {}),
        visited_at);
}

void HistoryStore::PersistedStorage::update_title(String const& url, String const& title)
{
    m_database.execute_statement(
        m_statements.update_title,
        {},
        title,
        url);
}

void HistoryStore::PersistedStorage::update_favicon(String const& url, String const& favicon_base64_png)
{
    m_database.execute_statement(
        m_statements.update_favicon,
        {},
        favicon_base64_png,
        url);
}

Optional<HistoryEntry> HistoryStore::PersistedStorage::entry_for_url(String const& url)
{
    Optional<HistoryEntry> entry;

    m_database.execute_statement(
        m_statements.get_entry,
        [&](auto statement_id) {
            auto title = m_database.result_column<String>(statement_id, 0);
            auto favicon = m_database.result_column<String>(statement_id, 3);

            entry = HistoryEntry {
                .url = url,
                .title = title.is_empty() ? Optional<String> {} : Optional<String> { move(title) },
                .favicon_base64_png = favicon.is_empty() ? Optional<String> {} : Optional<String> { move(favicon) },
                .visit_count = m_database.result_column<u64>(statement_id, 1),
                .last_visited_time = m_database.result_column<UnixDateTime>(statement_id, 2),
            };
        },
        url);

    return entry;
}

Vector<HistoryEntry> HistoryStore::PersistedStorage::autocomplete_entries(StringView title_query, StringView url_query, size_t limit)
{
    Vector<HistoryEntry> entries;
    entries.ensure_capacity(min(limit, DEFAULT_AUTOCOMPLETE_SUGGESTION_LIMIT));
    auto url_query_string = MUST(String::from_utf8(url_query));
    auto title_query_string = MUST(String::from_utf8(title_query));
    auto url_contains_query_string = MUST(String::from_utf8(autocomplete_url_contains_query(url_query)));

    m_database.execute_statement(
        m_statements.search_entries,
        [&](auto statement_id) {
            auto title = m_database.result_column<String>(statement_id, 1);
            auto favicon = m_database.result_column<String>(statement_id, 4);

            entries.append(HistoryEntry {
                .url = m_database.result_column<String>(statement_id, 0),
                .title = title.is_empty() ? Optional<String> {} : Optional<String> { move(title) },
                .favicon_base64_png = favicon.is_empty() ? Optional<String> {} : Optional<String> { move(favicon) },
                .visit_count = m_database.result_column<u64>(statement_id, 2),
                .last_visited_time = m_database.result_column<UnixDateTime>(statement_id, 3),
            });
        },
        url_query_string,
        url_contains_query_string,
        title_query_string,
        static_cast<i64>(limit));

    return entries;
}

void HistoryStore::PersistedStorage::clear()
{
    m_database.execute_statement(m_statements.clear_entries, {});
}

void HistoryStore::PersistedStorage::remove_entries_accessed_since(UnixDateTime since)
{
    m_database.execute_statement(m_statements.delete_entries_accessed_since, {}, since);
}

}