#include "addr.hpp"

#include <algorithm>
#include <chrono>
#include <random>
#include <thread>

DaliAddr::DaliAddr(DaliBase& base) : base_(base) {}

bool DaliAddr::isAllocAddr() const { return base_.isAllocAddr; }

void DaliAddr::setIsAllocAddr(bool value) { base_.isAllocAddr = value; }

int DaliAddr::lastAllocAddr() const { return base_.lastAllocAddr; }

void DaliAddr::setLastAllocAddr(int value) { base_.lastAllocAddr = value; }

void DaliAddr::selectDevice(int address) { base_.selectedAddress = address; }

bool DaliAddr::writeAddr(int addr, int newAddr) {
  const int nAddr = newAddr * 2 + 1;
  return base_.setDTR(nAddr) && base_.storeDTRAsAddr(addr);
}

bool DaliAddr::removeAddr(int addr) { return base_.setDTR(0xFF) && base_.storeDTRAsAddr(addr); }

bool DaliAddr::removeAllAddr() { return removeAddr(base_.broadcast); }

std::vector<int> DaliAddr::searchAddr(int addr) {
  isSearching = true;
  onlineDevices.clear();

  const int maxAddr = std::clamp(addr, 0, 63);
  for (int i = 0; i < maxAddr; i++) {
    if (!isSearching) break;
    const auto status = base_.getOnlineStatus(i);
    if (status.has_value() && status.value()) {
      onlineDevices.push_back(i);
    }
  }

  isSearching = false;
  return onlineDevices;
}

std::vector<int> DaliAddr::searchAddrRange(int start, int end) {
  int s = std::clamp(start, 0, 63);
  int e = std::clamp(end, 0, 63);
  if (s > e) return {};

  isSearching = true;
  onlineDevices.clear();

  for (int i = s; i <= e; i++) {
    if (!isSearching) break;
    const auto status = base_.getOnlineStatus(i);
    if (status.has_value() && status.value()) {
      onlineDevices.push_back(i);
    }
  }

  isSearching = false;
  return onlineDevices;
}

void DaliAddr::stopSearch() { isSearching = false; }

bool DaliAddr::compareSingleAddress(int typ, int addr) {
  bool ok = false;
  if (typ == 1) {
    ok = base_.queryAddressH(addr);
  } else if (typ == 2) {
    ok = base_.queryAddressM(addr);
  } else if (typ == 3) {
    ok = base_.queryAddressL(addr);
  }
  if (!ok) return false;
  const auto matched = base_.compareAddress();
  return matched.has_value() && matched.value();
}

std::pair<int, int> DaliAddr::precompareNew(int typ, int m) {
  int min = m;
  int max = 255;
  while ((max - min) > 6) {
    const int mid = static_cast<int>((max - min) / 2.0 + min);
    const bool ok = compareSingleAddress(typ, mid);
    if (ok) {
      max = mid;
    } else {
      min = mid;
    }
  }
  return {min, max};
}

int DaliAddr::compareAddress(int typ) {
  int min = 0;
  int max = 255;
  int vAct = 0;
  const auto mm = precompareNew(typ);
  min = mm.first;
  max = mm.second;

  std::mt19937 rng(528643246);

  for (int i = 0; i <= 100; i++) {
    if (!base_.isAllocAddr) break;
    if (min >= max) break;

    std::uniform_int_distribution<int> dist(min, max);
    const int v = dist(rng);
    const bool res = compareSingleAddress(typ, v);

    if (res) {
      if (v == 0) {
        vAct = v;
        compareSingleAddress(typ, v);
        break;
      }
      const bool res2 = compareSingleAddress(typ, v - 1);
      if (res2) {
        max = v - 1;
      } else {
        vAct = v - 1;
        compareSingleAddress(typ, v - 1);
        break;
      }
    } else if (v <= 254) {
      const bool res3 = compareSingleAddress(typ, v + 1);
      if (res3) {
        vAct = v;
        compareSingleAddress(typ, v);
        break;
      }
      min = v + 1;
    } else {
      break;
    }
  }

  return vAct;
}

int DaliAddr::compareAddressNew(int typ, int m) {
  int minVal = m;
  int maxVal = 255;
  int vAct = 0;
  const auto mm = precompareNew(typ, minVal);
  minVal = mm.first;
  maxVal = mm.second;
  int v = maxVal;

  for (int i = 0; i <= 10; i++) {
    const bool ok = compareSingleAddress(typ, v);
    if (ok) {
      if (v == 0) {
        vAct = v;
        compareSingleAddress(typ, v);
        break;
      }
      const bool ok2 = compareSingleAddress(typ, v - 1);
      if (ok2) {
        maxVal = v - 1;
      } else {
        vAct = v - 1;
        compareSingleAddress(typ, v - 1);
        break;
      }
    }
  }

  return vAct;
}

DaliCompareAddrResult DaliAddr::compareAddr(int ad, std::optional<int> /*minH*/,
                                            std::optional<int> /*minM*/, std::optional<int> /*minL*/) {
  DaliCompareAddrResult result;
  result.nextAddr = ad;

  if (ad > 63) {
    result.nextAddr = 63;
    return result;
  }

  base_.compare(128, 0, 0);
  result.retH = compareAddress(1);
  result.retM = compareAddress(2);
  result.retL = compareAddress(3);

  if (!base_.isAllocAddr) {
    result.retH = 0;
    result.retM = 0;
    result.retL = 0;
    return result;
  }

  if (result.retH == 0 && result.retM == 0 && result.retL == 0) {
    return result;
  }

  const auto res = base_.compare(result.retH, result.retM, result.retL + 1);
  if (!res.has_value() || !res.value()) {
    base_.isAllocAddr = false;
    result.retH = 0;
    result.retM = 0;
    result.retL = 0;
    return result;
  }

  while (true) {
    const auto status = base_.getOnlineStatus(ad);
    if (!status.has_value() || !status.value()) break;
    ad++;
    if (ad > 63) break;
  }

  if (!base_.programShortAddr(ad)) return result;
  const auto qsa = base_.queryShortAddr();
  if (qsa.has_value() && qsa.value() == ad) {
    base_.withdraw();
    base_.setBright(ad, 254);
  }

  result.nextAddr = ad;
  return result;
}

int DaliAddr::compareMulti(int h, int m, int l, int ad) {
  int addr = ad + 1;
  int retL = l;
  int retM = m;
  int retH = h;

  for (int i = 0; i < 64; i++) {
    if (!base_.isAllocAddr) return addr - 1;

    if (addr > 63) {
      return addr - 1;
    }

    retL++;
    if (retL > 255) {
      retL = 0;
      retM++;
      if (retM > 255) {
        retM = 0;
        retH++;
        if (retH > 255) {
          break;
        }
      }
    }

    const auto ok = base_.compare(retH, retM, retL);
    if (!ok.has_value() || !ok.value()) {
      addr--;
      break;
    }

    while (true) {
      const auto status = base_.getOnlineStatus(addr);
      if (!status.has_value() || !status.value()) break;
      addr++;
      if (addr > 63) {
        return addr - 1;
      }
    }

    if (!base_.programShortAddr(addr)) continue;
    const auto qsa = base_.queryShortAddr();
    if (qsa.has_value() && qsa.value() == addr) {
      base_.withdraw();
      base_.setBright(addr, 254);
      addr++;
    }
  }

  return addr;
}

bool DaliAddr::allocateAllAddr(int ads) {
  int ad = ads;
  base_.isAllocAddr = true;
  base_.lastAllocAddr = 255;

  for (int i = 0; i <= 80; i++) {
    if (!base_.isAllocAddr) break;

    bool anyDevice = false;
    const auto dev1 = base_.compare(255, 255, 255);
    if (dev1.has_value() && dev1.value()) {
      anyDevice = true;
      std::this_thread::sleep_for(std::chrono::milliseconds(100));
    } else {
      const auto dev2 = base_.compare(255, 255, 255);
      if (dev2.has_value() && dev2.value()) {
        anyDevice = true;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
      } else {
        const auto dev3 = base_.compare(255, 255, 255);
        if (dev3.has_value() && dev3.value()) {
          anyDevice = true;
          std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
      }
    }

    if (!anyDevice) {
      break;
    }

    const auto retVals = compareAddr(ad, std::nullopt, std::nullopt, std::nullopt);
    ad = retVals.nextAddr;
    if (!base_.isAllocAddr) break;

    if (!(retVals.retH == 0 && retVals.retM == 0 && retVals.retL == 0)) {
      i = 0;
    }

    ad = compareMulti(retVals.retH, retVals.retM, retVals.retL + 1, ad);
    base_.lastAllocAddr = ad;
    ad++;

    if (ad > 63) {
      base_.isAllocAddr = false;
      break;
    }

    if (i == 80) {
      base_.isAllocAddr = false;
      break;
    }
  }

  base_.isAllocAddr = false;
  if (ad <= 0) {
    base_.lastAllocAddr = 255;
  } else {
    base_.lastAllocAddr = ad - 1;
  }
  return true;
}

void DaliAddr::stopAllocAddr() { base_.isAllocAddr = false; }

bool DaliAddr::removeFromScene(int addr, int scene) {
  const int value = scene + 80;
  return base_.send(addr, static_cast<uint8_t>(value));
}

std::optional<int> DaliAddr::getSceneBright(int addr, int scene) {
  const int value = scene + 176;
  return base_.query(addr, static_cast<uint8_t>(value));
}

bool DaliAddr::resetAndAllocAddr(int n, bool removeAddrFirst, bool closeLight) {
  const int startTime = static_cast<int>(base_.mcuTicks());
  base_.isAllocAddr = true;

  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  if (closeLight) {
    base_.off(base_.broadcast);
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
  }

  if (!base_.terminate()) {
    base_.isAllocAddr = false;
    return false;
  }
  std::this_thread::sleep_for(std::chrono::milliseconds(200));

  if (removeAddrFirst) {
    if (!base_.initialiseAll()) {
      base_.isAllocAddr = false;
      return false;
    }
    std::this_thread::sleep_for(std::chrono::milliseconds(200));
    if (!removeAllAddr()) {
      base_.isAllocAddr = false;
      return false;
    }
  } else {
    if (!base_.initialise()) {
      base_.isAllocAddr = false;
      return false;
    }
  }

  std::this_thread::sleep_for(std::chrono::milliseconds(500));
  if (!base_.randomise()) {
    base_.isAllocAddr = false;
    return false;
  }
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  if (!base_.randomise()) {
    base_.isAllocAddr = false;
    return false;
  }
  std::this_thread::sleep_for(std::chrono::milliseconds(300));

  const bool ok = allocateAllAddr(n);
  (void)startTime;
  return ok;
}