#include "tlbmc/hal/fake_fru_scanner_fram.h"

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>

#include "absl/log/log.h"
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_cat.h"
#include "absl/synchronization/mutex.h"
#include "absl/time/time.h"
#include "tlbmc/hal/fru_scanner.h"

namespace milotic_tlbmc {

absl::StatusOr<std::unique_ptr<I2cFruInfo>>
FakeFruScannerFram::GetI2cFruInfoFromBus(
    int bus, int address, absl::Duration delay_between_reads) const {
  // Simulate cavium being busy
  if (GetCaviumBusy()) {
    return absl::UnavailableError("Cavium is busy");
  }
  LOG(INFO) << "FakeFruScannerFram::GetI2cFruInfoFromBus called for bus " << bus
            << " address " << address;
  if (bus == options_.bus && address == options_.address) {
    auto fake_fru_info = std::make_unique<I2cFruInfo>();
    fake_fru_info->bus = bus;
    fake_fru_info->address = address;
    fake_fru_info->data = GetCaviumFramData(kCaviumFramDataSize);
    return fake_fru_info;
  }
  return absl::NotFoundError(absl::StrCat("No fake data configured for bus ",
                                          bus, " address ", address));
}

absl::StatusOr<std::vector<std::unique_ptr<I2cFruInfo>>>
FakeFruScannerFram::ScanAllI2cFrus() const {
  LOG(INFO) << "FakeFruScannerFram::ScanAllI2cFrus called";
  // Simulate cavium being busy
  if (GetCaviumBusy()) {
    return std::vector<std::unique_ptr<I2cFruInfo>>();
  }
  std::vector<std::unique_ptr<I2cFruInfo>> frus;
  auto fru_info = GetI2cFruInfoFromBus(options_.bus, options_.address,
                                       absl::Milliseconds(1));
  if (!fru_info.ok()) {
    LOG(ERROR) << "Failed to read FRAM at bus " << options_.bus << " address "
               << options_.address << " with status: " << fru_info.status();
    return fru_info.status();
  }
  frus.push_back(std::move(*fru_info));
  return frus;
}

std::vector<uint8_t> FakeFruScannerFram::GetCaviumFramData(size_t size) {
  size_t copy_size = std::min(size, kCaviumFramDataSize);
  std::vector<uint8_t> data(kCaviumFramData, kCaviumFramData + copy_size);
  LOG(INFO) << "GetI2cDumpTestData returning data of size: " << data.size();
  return data;
}

void FakeFruScannerFram::SetCaviumBusy(bool cavium_busy) {
  absl::MutexLock lock(mutex_);
  cavium_busy_ = cavium_busy;
}

bool FakeFruScannerFram::GetCaviumBusy() const {
  absl::MutexLock lock(mutex_);
  return cavium_busy_;
}

}  // namespace milotic_tlbmc