#define SETTINGS_SCREEN_TEST
#include "../components/smart_display/settings_screen.h"
#include <cassert>
#include <string>

using namespace settings_screen;

// The row of a page by its label, so a test says what it means.
static const Row &row_named(const Page &page, const std::string &label) {
  for (uint8_t i = 0; i < page.count; ++i)
    if (label == page.rows[i].label) return page.rows[i];
  assert(false);
  return page.rows[0];
}

int main() {
  // ---- the duration ladder: seconds low down, quarters of an hour up top, and symmetric ----
  assert(ladder_step(60) == 30 && ladder_step(600) == 60 && ladder_step(1800) == 300);
  assert(ladder_step(3600) == 900 && ladder_step(36000) == 1800);
  Row timeout = duration("After", nullptr, nullptr, 30, 3600);
  assert(stepped(timeout, 120, 1) == 150 && stepped(timeout, 120, -1) == 90);
  assert(stepped(timeout, 300, 1) == 360 && stepped(timeout, 360, -1) == 300);
  assert(stepped(timeout, 300, -1) == 270 && stepped(timeout, 270, 1) == 300);
  assert(stepped(timeout, 30, -1) == 30 && stepped(timeout, 3600, 1) == 3600);
  assert(at_end(timeout, 30, -1) && at_end(timeout, 3600, 1) && !at_end(timeout, 120, -1));

  // ---- a number stops at its ends, a moment walks around midnight ----
  Row percent = number("Brightness", nullptr, nullptr, 5, 100, 5, "%");
  assert(stepped(percent, 100, 1) == 100 && stepped(percent, 5, -1) == 5 && stepped(percent, 95, 1) == 100);
  Row start = moment("Starts", nullptr, nullptr);
  assert(stepped(start, 1320, 1) == 1335 && stepped(start, 1425, 1) == 0 && stepped(start, 0, -1) == 1425);
  assert(!at_end(start, 0, -1));
  // Holding the key walks whole hours, and first lands on the hour it is in.
  assert(stepped(start, 1320, 1, true) == 1380 && stepped(start, 1320, -1, true) == 1260);
  assert(stepped(start, 1327, 1, true) == 1380 && stepped(start, 1327, -1, true) == 1320);
  assert(stepped(start, 1380, 1, true) == 1440 % 1440);   // 23:00 + 1 h wraps to 00:00
  assert(stepped(start, 0, -1, true) == 1380);            // 00:00 - 1 h is 23:00

  // ---- texts ----
  assert(duration_text(45) == "45 sec" && duration_text(60) == "1 min" && duration_text(120) == "2 min");
  assert(duration_text(3600) == "1 h" && duration_text(5400) == "1 h 30" && duration_text(86400) == "24 h");
  assert(moment_text(1320, true) == "22:00" && moment_text(0, true) == "00:00");
  assert(moment_text(1320, false) == "10:00 PM" && moment_text(0, false) == "12:00 AM");
  assert(moment_text(750, false) == "12:30 PM" && moment_text(60, false) == "1:00 AM");

  // ---- rows read and write the real settings ----
  screen_settings::current = screen_settings::Settings{};
  const Page &light = pages[1];
  const Row &brightness = row_named(light, "Brightness");
  assert(value_text(brightness) == "100%");
  brightness.write(40);
  assert(screen_settings::current.brightness == 40 && value_text(brightness) == "40%");
  // Lowering the normal brightness pulls the two dim levels down with it, exactly like the add-on.
  screen_settings::current.standby_brightness = 60;
  brightness.write(30);
  assert(screen_settings::current.standby_brightness == 30);
  const Row &standby = row_named(light, "Standby brightness");
  standby.write(90);
  assert(screen_settings::current.standby_brightness == 30);  // never above the normal brightness
  assert(screen_settings::current.valid());

  const Page &screen = pages[3];
  const Row &clock = row_named(screen, "Clock");
  assert(clock.option_count == 2 && value_text(clock) == "24 hour");
  clock.write(0);
  assert(screen_settings::current.clock_24h == 0 && value_text(clock) == "12 hour");
  const Row &home = row_named(screen, "Back to page 1");
  home.write(0);
  assert(auto_home == 0 && value_text(home) == "Off");
  const Row &rotate = row_named(screen, "Rotation");
  rotation_supported = false;
  assert(!visible_row(rotate));  // a board that cannot turn never shows the row
  rotation_supported = true;
  assert(visible_row(rotate));
  rotate.write(2);
  assert(rotation == 180 && value_text(rotate) == "180°");
  rotate.write(3);
  assert(rotation == 270);
  rotate.write(0);
  assert(rotation == 0);

  // ---- every page hangs together: menu rows open a real page, controls can be worked ----
  assert(PAGE_COUNT == 5);
  for (uint8_t p = 0; p < PAGE_COUNT; ++p) {
    const Page &page = pages[p];
    assert(page.title && page.count && page.count <= 8);
    for (uint8_t i = 0; i < page.count; ++i) {
      const Row &row = page.rows[i];
      assert(row.label && *row.label);
      if (row.kind == Kind::page) assert(row.opens > 0 && row.opens < PAGE_COUNT && *row.icon);
      if (row.kind == Kind::toggle || row.kind == Kind::choice || row.kind == Kind::number ||
          row.kind == Kind::duration || row.kind == Kind::moment)
        assert(row.read && row.write);
      if (row.kind == Kind::number) assert(row.step > 0 && row.high > row.low);
      if (row.kind == Kind::duration) assert(row.high > row.low);
      if (row.kind == Kind::choice) assert(row.options && row.option_count);
      if (row.kind == Kind::info) assert(row.text);
      if (row.kind == Kind::action) assert(row.run && *row.icon);
    }
  }
  // Every page is reachable from the menu.
  bool reached[PAGE_COUNT] = {true};
  for (uint8_t i = 0; i < pages[0].count; ++i) reached[pages[0].rows[i].opens] = true;
  for (bool page : reached) assert(page);

  // ---- how many rows fit, and when the pager appears ----
  bool paged = false;
  assert(fitting_rows(180, 34, 4, 26, 4, paged) == 4 && !paged);   // CYD: four rows, no pager
  assert(fitting_rows(180, 34, 4, 26, 6, paged) == 4 && paged);    // six rows: 4 + 2
  assert(fitting_rows(372, 52, 8, 40, 6, paged) == 6 && !paged);   // Guition: the whole group at once
  assert(fitting_rows(372, 52, 8, 40, 9, paged) == 5 && paged);
  assert(fitting_rows(40, 34, 4, 26, 5, paged) >= 1);              // never zero rows

  // ---- a change is stored, applied and reported once ----
  static int stored = 0, applied = 0;
  static std::string last_key;
  static int32_t last_value = 0;
  store = [] { ++stored; };
  apply = [] { ++applied; };
  report = [](const char *key, int32_t value) { last_key = key; last_value = value; };
  row_named(light, "Auto standby").write(0);
  assert(stored == 1 && applied == 1 && last_key == "standby_enabled" && last_value == 0);
  row_named(screen, "After").write(600);
  assert(stored == 2 && last_key == "auto_home_seconds" && last_value == 600 && auto_home_seconds == 600);
}