#pragma once
#include "order.hpp"

namespace orders {
class OrderRepository {
public:
  virtual ~OrderRepository() = default;
  virtual Result<std::vector<Order>> list() const = 0;
  // Contract: failure leaves the previously committed batch intact.
  virtual Result<Done> replaceAll(std::span<const Order> batch) = 0;
};
class MemoryRepository final : public OrderRepository {
  std::vector<Order> data_;

public:
  Result<std::vector<Order>> list() const override { return data_; }
  Result<Done> replaceAll(std::span<const Order> batch) override {
    return replaceValidated(data_, batch);
  }
};
class OrderService {
  OrderRepository &repository_;

public:
  explicit OrderService(OrderRepository &repository)
      : repository_(repository) {}
  Result<std::vector<Order>> list() const { return repository_.list(); }
  Result<Done> replace(std::span<const Order> batch) {
    auto result = validateBatch(batch);
    if (!succeeded(result))
      return std::get<Error>(result);
    return repository_.replaceAll(batch);
  }
  Result<Done> save(const Order &order) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    auto found = std::ranges::find(batch, order.id, &Order::id);
    if (found == batch.end())
      batch.push_back(order);
    else
      *found = order;
    return replace(batch);
  }
  Result<Done> remove(int id) {
    auto result = repository_.list();
    if (!succeeded(result))
      return std::get<Error>(result);
    auto batch = std::get<std::vector<Order>>(std::move(result));
    std::erase_if(batch, [id](const Order &order) { return order.id == id; });
    return replace(batch);
  }
};
} // namespace orders
