Types and Enums

#include <nrvna/types.hpp>

using JobId = std::string;

JobId id = "550e8400-e29b-41d4-a716-446655440000";
std::cout << "Job ID: " << id << std::endl;

enum class Status : std::uint8_t {
    Queued,   // Job submitted, waiting for processing
    Running,  // Job currently being processed
    Done,     // Job completed successfully
    Failed,   // Job failed with error
    Missing   // Job not found in workspace
};

Status status = flow.status(jobId);

switch (status) {
    case Status::Queued:
        std::cout << "Waiting in queue" << std::endl;
        break;
    case Status::Running:
        std::cout << "Processing..." << std::endl;
        break;
    case Status::Done:
        std::cout << "Complete!" << std::endl;
        break;
    case Status::Failed:
        std::cout << "Failed" << std::endl;
        break;
    case Status::Missing:
        std::cout << "Not found" << std::endl;
        break;
}

enum class JobType : uint8_t {
    Text = 0,   // Text generation
    Embed = 1,  // Embedding generation
    Vision = 2  // Vision/multimodal processing
};

// Text generation
auto result1 = work.submit("Hello", JobType::Text);

// Embedding
auto result2 = work.submit("Hello", JobType::Embed);

// Vision (automatically set when using image overload)
auto result3 = work.submit("Describe this", imagePaths);

enum class SubmissionError : uint8_t {
    None = 0,           // No error occurred
    IoError,            // Filesystem I/O error
    InvalidSize,        // Prompt exceeds maximum size
    InvalidContent,     // Invalid prompt or image content
    WorkspaceError      // Workspace not accessible or invalid
};

auto result = work.submit(largePrompt);
if (!result) {
    switch (result.error) {
        case SubmissionError::None:
            // Won't happen when result.ok is false
            break;
        case SubmissionError::IoError:
            std::cerr << "I/O error: " << result.message << std::endl;
            break;
        case SubmissionError::InvalidSize:
            std::cerr << "Prompt too large" << std::endl;
            break;
        case SubmissionError::InvalidContent:
            std::cerr << "Invalid content: " << result.message << std::endl;
            break;
        case SubmissionError::WorkspaceError:
            std::cerr << "Workspace error: " << result.message << std::endl;
            break;
    }
}

struct SubmitResult {
    bool ok = false;
    JobId id;
    SubmissionError error = SubmissionError::None;
    std::string message;
    explicit operator bool() const noexcept { return ok; }
};

auto result = work.submit("Test prompt");

// Check using operator bool
if (result) {
    std::cout << "Success! Job ID: " << result.id << std::endl;
    std::cout << "Message: " << result.message << std::endl;
} else {
    std::cerr << "Failed with error " << static_cast<int>(result.error) << std::endl;
    std::cerr << "Message: " << result.message << std::endl;
}

// Or check directly
if (result.ok) {
    // ...
}

struct Job {
    JobId id;
    Status status;
    std::string content;
    std::chrono::system_clock::time_point timestamp;
};

auto job = flow.latest();
if (job) {
    std::cout << "Job ID: " << job->id << std::endl;
    
    // Format timestamp
    auto time_t = std::chrono::system_clock::to_time_t(job->timestamp);
    std::cout << "Timestamp: " << std::ctime(&time_t);
    
    // Check status and content
    if (job->status == Status::Done) {
        std::cout << "Result: " << job->content << std::endl;
    } else if (job->status == Status::Failed) {
        std::cerr << "Error: " << job->content << std::endl;
    }
}

std::string statusToString(Status status) {
    switch (status) {
        case Status::Queued:  return "Queued";
        case Status::Running: return "Running";
        case Status::Done:    return "Done";
        case Status::Failed:  return "Failed";
        case Status::Missing: return "Missing";
        default:              return "Unknown";
    }
}

std::string jobTypeToString(JobType type) {
    switch (type) {
        case JobType::Text:   return "Text";
        case JobType::Embed:  return "Embed";
        case JobType::Vision: return "Vision";
        default:              return "Unknown";
    }
}