#pragma once

// Read/write access to the `tasks` table, plus the projection onto the wire TaskSummary.
// download.list does its filtering, sorting and paging here (M1 DoD: a 1000-row list under
// 50 ms, never materialised client-side).

#include <cstdint>
#include <optional>
#include <string>
#include <vector>

#include "store/sqlite.hpp"
#include "velox_proto.hpp"

namespace velox::daemon::store {

// One row of `tasks`, 1:1 with the schema. std::optional maps a NULL column.
struct TaskRow {
    std::string task_id;
    std::string url;
    std::string save_dir;
    std::string filename;
    std::string state = "new";
    std::string start_mode = "now";  // contract StartMode: 'now'|'later'|'queue'
    std::string created_at;

    std::optional<std::string> effective_url;
    std::optional<std::string> category_id;
    std::optional<std::string> queue_id;
    std::optional<std::string> description;
    std::optional<std::string> pause_reason;
    std::optional<std::string> etag;
    std::optional<std::string> last_modified;
    std::optional<std::string> content_type;
    std::optional<std::string> last_try_at;
    std::optional<std::string> completed_at;
    std::optional<std::string> checksum_algo;
    std::optional<std::string> checksum_value;

    std::optional<std::int64_t> size_bytes;
    std::int64_t downloaded_bytes = 0;
    std::int64_t speed_bps = 0;
    bool resumable = false;

    std::optional<std::int64_t> req_segments;
    std::int64_t eff_segments = 0;
    std::optional<std::int64_t> req_buffer_bytes;
    std::optional<std::int64_t> eff_buffer_bytes;
    std::optional<std::int64_t> queue_position;

    std::optional<std::string> error_code;
    std::optional<std::string> error_message;
    std::optional<std::int64_t> error_http_status;
    std::optional<bool> error_retryable;
    std::optional<std::int64_t> error_attempt;
    std::optional<std::string> error_next_retry_at;
};

class Tasks {
public:
    explicit Tasks(Db& db) : db_(db) {}

    DbResult<void> insert(const TaskRow& row);
    DbResult<std::optional<TaskRow>> get(std::string_view task_id);

    struct Page {
        std::int64_t total = 0;                 // rows matching the filter, ignoring paging
        std::vector<TaskRow> rows;
    };
    DbResult<Page> list(const std::optional<velox::proto::TaskFilter>& filter,
                        const std::optional<velox::proto::TaskSort>& sort, std::int64_t offset,
                        std::int64_t limit);

    // Move a task to `state`; `pause_reason` is written only when state == "paused"
    // (cleared otherwise). Returns false if there is no such task.
    DbResult<bool> set_state(std::string_view task_id, std::string_view state,
                             const std::optional<std::string>& pause_reason);

    DbResult<bool> remove(std::string_view task_id);
    DbResult<std::int64_t> count();

    // capture.offer's dedupe check: true if a non-terminal task already targets this exact
    // URL (the same rule download.add itself does not enforce — a deliberate re-add is
    // allowed there; capture is the automatic path where re-grabbing an in-flight download
    // is almost always a mistake, e.g. two tabs triggering the same link).
    DbResult<bool> has_active_duplicate(std::string_view url);

    // download.update's patch, already resolved by the caller (new save_dir/filename
    // canonicalized and root-checked, any file already moved on disk — this only writes
    // the row). Every field is applied when present; queue_position is written alongside
    // queue_id (nullopt leaves the existing position alone — the caller decides what
    // "moved into a queue" should set it to). Note: the generated parser collapses "field
    // absent" and "field explicitly null" to the same nullopt (DownloadUpdateParamsPatch
    // has no way to tell them apart on the wire as generated), so this — like the RPC
    // layer above it — can only ever set category_id/queue_id/description/checksum, never
    // clear them back to NULL through this call.
    struct UpdatePatch {
        std::optional<std::string> save_dir;
        std::optional<std::string> filename;
        std::optional<std::string> category_id;
        std::optional<std::string> queue_id;
        std::optional<std::int64_t> queue_position;
        std::optional<std::string> description;
        std::optional<std::int64_t> req_segments;
        std::optional<std::int64_t> req_buffer_bytes;
        std::optional<std::string> checksum_algo;
        std::optional<std::string> checksum_value;
    };
    DbResult<bool> apply_update(std::string_view task_id, const UpdatePatch& patch);

    // download.refreshUrl: point the task at a freshly-issued URL. Separate from
    // apply_update/set_probe_result since neither owns the base `url` column — refreshUrl
    // is the one caller that changes it after creation.
    DbResult<bool> set_url(std::string_view task_id, std::string_view url);

    // Byte-counter update from an engine progress tick — cheaper than a full row rewrite,
    // and keeps download.list / download.get current between state transitions.
    DbResult<bool> update_progress(std::string_view task_id, std::int64_t downloaded_bytes,
                                   std::int64_t speed_bps, std::int64_t eff_segments,
                                   std::int64_t eff_buffer_bytes);

    // What the probe learned, persisted before start() so a task that completes before any
    // progress tick still reports a real sizeBytes / resumable (not the pre-probe default).
    struct ProbeFields {
        std::optional<std::int64_t> size_bytes;
        bool resumable = false;
        std::optional<std::string> etag;
        std::optional<std::string> last_modified;
        std::optional<std::string> content_type;
        std::optional<std::string> effective_url;
    };
    DbResult<bool> set_probe_result(std::string_view task_id, const ProbeFields& fields);

    // on_finished's byte count, for a task that completes before any progress tick ever
    // ran (see AGENT-DAEMON review: the bug this closes). size_bytes is only filled in if
    // still unset — the probe's total_size is the more authoritative source when both
    // exist and happen to disagree (a chunked source with no declared length, say).
    DbResult<bool> set_final_bytes(std::string_view task_id, std::int64_t bytes);

private:
    Db& db_;
};

// Project a row onto the wire type. `state` and `error.code` strings are assumed valid
// (the CHECK constraints and the state machine keep them so).
velox::proto::TaskSummary to_summary(const TaskRow& row);

}  // namespace velox::daemon::store