#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 = "auto";
    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;
    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();

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