#include "StartupSdManager.h"

#include <stdarg.h>
#include "driver/gpio.h"

StartupSdManager::StartupSdManager(Print& serial) : serial_(serial) {}

bool StartupSdManager::begin(const SdWatcherConfig& cfg, SdStatusCallback callback) {
  cfg_ = cfg;
  callback_ = callback;

  forceSpiDeselected();
  dumpSdPins("very-early");

  if (!initPmuForSdPower()) {
    return false;
  }

  cycleSdRail();
  delay(cfg_.startupWarmupMs);

  bool warmMounted = false;
  for (uint8_t i = 0; i < 3; ++i) {
    if (mountPreferred(false)) {
      warmMounted = true;
      break;
    }
    delay(200);
  }

  // Some cards need a longer power/settle window after cold boot.
  // Before declaring ABSENT, retry with extended settle and a full scan.
  if (!warmMounted) {
    logf("Watcher: startup preferred mount failed, retrying with extended settle");
    cycleSdRail(400, 1200);
    delay(cfg_.startupWarmupMs + 1500);
    warmMounted = mountCardFullScan();
  }

  if (warmMounted) {
    setStateMounted();
  } else {
    setStateAbsent();
  }
  return true;
}

void StartupSdManager::update() {
  const uint32_t now = millis();
  const uint32_t pollInterval =
      (watchState_ == SdWatchState::MOUNTED) ? cfg_.pollIntervalMountedMs : cfg_.pollIntervalAbsentMs;

  if ((uint32_t)(now - lastPollMs_) < pollInterval) {
    return;
  }
  lastPollMs_ = now;

  if (watchState_ == SdWatchState::MOUNTED) {
    if (verifyMountedCard()) {
      presentVotes_ = 0;
      absentVotes_ = 0;
      return;
    }

    if (mountPreferred(false) && verifyMountedCard()) {
      presentVotes_ = 0;
      absentVotes_ = 0;
      return;
    }

    absentVotes_++;
    presentVotes_ = 0;
    if (absentVotes_ >= cfg_.votesToAbsent) {
      setStateAbsent();
      absentVotes_ = 0;
    }
    return;
  }

  bool mounted = mountPreferred(false);
  if (!mounted && (uint32_t)(now - lastFullScanMs_) >= cfg_.fullScanIntervalMs) {
    lastFullScanMs_ = now;
    if (cfg_.recoveryRailCycleOnFullScan) {
      logf("Watcher: recovery rail cycle before full scan");
      cycleSdRail(cfg_.recoveryRailOffMs, cfg_.recoveryRailOnSettleMs);
      delay(150);
    }
    logf("Watcher: preferred probe failed, running full scan");
    mounted = mountCardFullScan();
  }

  if (mounted) {
    presentVotes_++;
    absentVotes_ = 0;
    if (presentVotes_ >= cfg_.votesToPresent) {
      setStateMounted();
      presentVotes_ = 0;
    }
  } else {
    absentVotes_++;
    presentVotes_ = 0;
    if (absentVotes_ >= cfg_.votesToAbsent) {
      setStateAbsent();
      absentVotes_ = 0;
    }
  }
}

bool StartupSdManager::consumeMountedEvent() {
  bool out = mountedEventPending_;
  mountedEventPending_ = false;
  return out;
}

bool StartupSdManager::consumeRemovedEvent() {
  bool out = removedEventPending_;
  removedEventPending_ = false;
  return out;
}

void StartupSdManager::logf(const char* fmt, ...) {
  char msg[196];
  va_list args;
  va_start(args, fmt);
  vsnprintf(msg, sizeof(msg), fmt, args);
  va_end(args);
  serial_.printf("[%10lu][%06lu] %s\r\n",
                 (unsigned long)millis(),
                 (unsigned long)logSeq_++,
                 msg);
}

void StartupSdManager::notify(SdEvent event, const char* message) {
  if (callback_ != nullptr) {
    callback_(event, message);
  }
}

void StartupSdManager::forceSpiDeselected() {
  pinMode(tbeam_supreme::sdCs(), OUTPUT);
  digitalWrite(tbeam_supreme::sdCs(), HIGH);
  pinMode(tbeam_supreme::imuCs(), OUTPUT);
  digitalWrite(tbeam_supreme::imuCs(), HIGH);
}

void StartupSdManager::dumpSdPins(const char* tag) {
  if (!cfg_.enablePinDumps) {
    (void)tag;
    return;
  }

  const gpio_num_t cs = (gpio_num_t)tbeam_supreme::sdCs();
  const gpio_num_t sck = (gpio_num_t)tbeam_supreme::sdSck();
  const gpio_num_t miso = (gpio_num_t)tbeam_supreme::sdMiso();
  const gpio_num_t mosi = (gpio_num_t)tbeam_supreme::sdMosi();
  logf("PINS(%s): CS=%d SCK=%d MISO=%d MOSI=%d",
       tag, gpio_get_level(cs), gpio_get_level(sck), gpio_get_level(miso), gpio_get_level(mosi));
}

bool StartupSdManager::initPmuForSdPower() {
  if (!tbeam_supreme::initPmuForPeripherals(pmu_, &serial_)) {
    logf("ERROR: PMU init failed");
    return false;
  }
  return true;
}

void StartupSdManager::cycleSdRail(uint32_t offMs, uint32_t onSettleMs) {
  if (!cfg_.enableSdRailCycle) {
    return;
  }
  if (!pmu_) {
    logf("SD rail cycle skipped: pmu=null");
    return;
  }

  forceSpiDeselected();
  pmu_->disablePowerOutput(XPOWERS_BLDO1);
  delay(offMs);
  pmu_->setPowerChannelVoltage(XPOWERS_BLDO1, 3300);
  pmu_->enablePowerOutput(XPOWERS_BLDO1);
  delay(onSettleMs);
}

bool StartupSdManager::tryMountWithBus(SPIClass& bus, const char* busName, uint32_t hz, bool verbose) {
  SD.end();
  bus.end();
  delay(10);
  forceSpiDeselected();

  bus.begin(tbeam_supreme::sdSck(), tbeam_supreme::sdMiso(), tbeam_supreme::sdMosi(), tbeam_supreme::sdCs());
  digitalWrite(tbeam_supreme::sdCs(), HIGH);
  delay(2);
  for (int i = 0; i < 10; i++) {
    bus.transfer(0xFF);
  }
  delay(2);

  if (verbose) {
    logf("SD: trying bus=%s freq=%lu Hz", busName, (unsigned long)hz);
  }

  if (!SD.begin(tbeam_supreme::sdCs(), bus, hz)) {
    if (verbose) {
      logf("SD: mount failed (possible non-FAT format, power, or bus issue)");
    }
    return false;
  }

  if (SD.cardType() == CARD_NONE) {
    SD.end();
    return false;
  }

  sdSpi_ = &bus;
  sdBusName_ = busName;
  sdFreq_ = hz;
  return true;
}

bool StartupSdManager::mountPreferred(bool verbose) {
  return tryMountWithBus(sdSpiH_, "HSPI", 400000, verbose);
}

bool StartupSdManager::mountCardFullScan() {
  const uint32_t freqs[] = {400000, 1000000, 4000000, 10000000};

  for (uint8_t i = 0; i < (sizeof(freqs) / sizeof(freqs[0])); ++i) {
    if (tryMountWithBus(sdSpiH_, "HSPI", freqs[i], true)) {
      logf("SD: card detected and mounted");
      return true;
    }
  }
  for (uint8_t i = 0; i < (sizeof(freqs) / sizeof(freqs[0])); ++i) {
    if (tryMountWithBus(sdSpiF_, "FSPI", freqs[i], true)) {
      logf("SD: card detected and mounted");
      return true;
    }
  }

  logf("SD: begin() failed on all bus/frequency attempts");
  return false;
}

bool StartupSdManager::verifyMountedCard() {
  File root = SD.open("/", FILE_READ);
  if (!root) {
    return false;
  }
  root.close();
  return true;
}

const char* StartupSdManager::cardTypeToString(uint8_t type) {
  switch (type) {
    case CARD_MMC:
      return "MMC";
    case CARD_SD:
      return "SDSC";
    case CARD_SDHC:
      return "SDHC/SDXC";
    default:
      return "UNKNOWN";
  }
}

void StartupSdManager::printCardInfo() {
  uint8_t cardType = SD.cardType();
  uint64_t cardSizeMB = SD.cardSize() / (1024ULL * 1024ULL);
  uint64_t totalMB = SD.totalBytes() / (1024ULL * 1024ULL);
  uint64_t usedMB = SD.usedBytes() / (1024ULL * 1024ULL);

  logf("SD type: %s", cardTypeToString(cardType));
  logf("SD size: %llu MB", cardSizeMB);
  logf("FS total: %llu MB", totalMB);
  logf("FS used : %llu MB", usedMB);
  logf("SPI bus: %s @ %lu Hz", sdBusName_, (unsigned long)sdFreq_);
}

bool StartupSdManager::ensureDirRecursive(const char* path) {
  String full(path);
  if (!full.startsWith("/")) {
    full = "/" + full;
  }

  int start = 1;
  while (start > 0 && start < (int)full.length()) {
    int slash = full.indexOf('/', start);
    String partial = (slash < 0) ? full : full.substring(0, slash);
    if (!SD.exists(partial.c_str()) && !SD.mkdir(partial.c_str())) {
      logf("ERROR: mkdir failed for %s", partial.c_str());
      return false;
    }
    if (slash < 0) {
      break;
    }
    start = slash + 1;
  }

  return true;
}

bool StartupSdManager::rewriteFile(const char* path, const char* payload) {
  if (SD.exists(path) && !SD.remove(path)) {
    logf("ERROR: failed to erase %s", path);
    return false;
  }

  File f = SD.open(path, FILE_WRITE);
  if (!f) {
    logf("ERROR: failed to create %s", path);
    return false;
  }

  size_t wrote = f.println(payload);
  f.close();
  if (wrote == 0) {
    logf("ERROR: write failed for %s", path);
    return false;
  }
  return true;
}

void StartupSdManager::permissionsDemo(const char* path) {
  logf("Permissions demo: FAT has no Unix chmod/chown, use open mode only.");
  File r = SD.open(path, FILE_READ);
  if (!r) {
    logf("Could not open %s as FILE_READ", path);
    return;
  }
  size_t writeInReadMode = r.print("attempt write while opened read-only");
  if (writeInReadMode == 0) {
    logf("As expected, FILE_READ write was blocked.");
  } else {
    logf("NOTE: FILE_READ write returned %u (unexpected)", (unsigned)writeInReadMode);
  }
  r.close();
}

void StartupSdManager::setStateMounted() {
  if (watchState_ != SdWatchState::MOUNTED) {
    logf("EVENT: card inserted/mounted");
    mountedEventPending_ = true;
    notify(SdEvent::CARD_MOUNTED, "SD card mounted");
  }
  watchState_ = SdWatchState::MOUNTED;
}

void StartupSdManager::setStateAbsent() {
  if (watchState_ == SdWatchState::MOUNTED) {
    logf("EVENT: card removed/unavailable");
    removedEventPending_ = true;
    notify(SdEvent::CARD_REMOVED, "SD card removed");
  } else if (watchState_ != SdWatchState::ABSENT) {
    logf("EVENT: no card detected");
    notify(SdEvent::NO_CARD, "Missing SD card or invalid FAT16/FAT32 format");
  }
  SD.end();
  watchState_ = SdWatchState::ABSENT;
}