Billigste timer i træk

/* @meta {
  "vc": {
    "price":  {"type": "number",  "config": {"name": "Price now", "min": 0, "max": 20, "meta": {"ui": {"view": "label", "unit": "DKK/kWh"}}}},
    "hours":  {"type": "number",  "config": {"name": "Hours in a row", "min": 1, "max": 12, "default_value": 3, "persisted": true, "meta": {"ui": {"view": "slider", "step": 1, "unit": "h"}}}},
    "ready":  {"type": "number",  "config": {"name": "Ready by (hour)", "min": 0, "max": 23, "default_value": 7, "persisted": true, "meta": {"ui": {"view": "slider", "step": 1, "unit": ":00"}}}},
    "active": {"type": "boolean", "config": {"name": "Cheap window now", "meta": {"ui": {"view": "label"}}}},
    "plan":   {"type": "text",    "config": {"name": "Plan", "meta": {"ui": {"view": "label"}}}},
    "avg":    {"type": "number",  "config": {"name": "Average price in window", "min": 0, "max": 20, "meta": {"ui": {"view": "label", "unit": "DKK/kWh"}}}},
    "group":  {"type": "group",   "config": {"name": "Cheapest hours"}}
  }
} */
// Cheapest hours in a row — Danish delivered price from stromligning.dk
// (spot + grid tariffs + taxes). Requires firmware 2.0.0 or newer.
// The script creates its own virtual components and puts them in a group.
// It switches nothing itself: "Cheap window now" is true while the cheapest
// window is running, and scenes or local actions switch the load on it.
// ===== CONFIGURATION =====
let CONFIG = {
  lat: "55.6736",         // Latitude
  long: "12.5681",        // Longitude
  additional_cost: 0.00,  // Extra cost from your electricity supplier, DKK/kWh
  fetch_delay_seconds: 10, // Seconds after each full hour the prices are fetched
  debug: false            // true = detailed log in the console, for troubleshooting
};
// ===== END OF CONFIGURATION =====
let H = 3600000;
let KVS_KEY = "cheapest_last_deadline";
print("Start");
let vPrice = Script.getVcHandle("price");
let vHours = Script.getVcHandle("hours");
let vReady = Script.getVcHandle("ready");
let vActive = Script.getVcHandle("active");
let vPlan = Script.getVcHandle("plan");
let vAvg = Script.getVcHandle("avg");
let vGroup = Script.getVcHandle("group");
let supplier = null;   // { id, area }
let prices = [];       // Hourly delivered prices, DKK/kWh
let firstTs = 0;       // Start of prices[0], ms
let plan = null;       // { start, end, avg, deadline }
let lastDeadline = 0;  // Deadline served by the last finished window. Kept in KVS across restarts
let waiting = false;   // True while tomorrow's prices are needed but not yet published
let wasActive = null;  // Last state written to the boolean
function pad2(n) {
  return ("0" + n).slice(-2);
}
function round2(v) {
  return Math.round(v * 100) / 100;
}
// Price components are limited to 0–20 DKK/kWh, so a value outside is clamped
function clampPrice(v) {
  return Math.min(20, Math.max(0, v));
}
function hourStart(ts) {
  return Math.floor(ts / H) * H;
}
function hhmm(ts) {
  return pad2(new Date(ts).getHours()) + ":00";
}
function dayHour(ts) {
  let d = new Date(ts);
  return d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " + hhmm(ts);
}
// ----- Debug: writes only, never changes a decision. Every caller checks
// CONFIG.debug first, so with debug off no debug string is even built -----
function dbg(s) {
  print("[debug] " + s);
}
function dbgTime(ts) {
  let d = new Date(ts);
  return d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) + " " +
    pad2(d.getHours()) + ":" + pad2(d.getMinutes());
}
function dbgCoord(v) {
  return Math.round(parseFloat(v) * 100) / 100;
}
// Prices as "18:2.31 19:2.10 …", at most 12 hours per line
function dbgPrices() {
  let line = "";
  for (let i = 0; i < prices.length; i++) {
    line += pad2(new Date(firstTs + i * H).getHours()) + ":" + prices[i].toFixed(2) + " ";
    if ((i + 1) % 12 === 0 || i === prices.length - 1) {
      dbg("prices " + line.trim());
      line = "";
    }
  }
}
function dbgStart() {
  let info = Shelly.getDeviceInfo();
  let sys = Shelly.getComponentConfig("sys");
  dbg("firmware " + (info ? (info.ver || info.fw_id) : "?") + ", model " + (info ? info.model : "?"));
  dbg("time zone " + (sys && sys.location ? sys.location.tz : "?") + ", local time " + dbgTime(Date.now()));
  dbg("config lat " + dbgCoord(CONFIG.lat) + ", long " + dbgCoord(CONFIG.long) +
    ", additional_cost " + CONFIG.additional_cost + ", fetch_delay_seconds " + CONFIG.fetch_delay_seconds);
}
// Never calls a handle that may be null, and never lets a failed write stop the script
function setVc(h, v) {
  if (!h) return;
  try {
    h.setValue(v);
  } catch (e) {
    print("Could not write a component: " + e.message);
  }
}
function getVc(h, fallback) {
  if (!h) return fallback;
  let v = h.getValue();
  return typeof v === "number" ? v : fallback;
}
// The script engine has no regular expressions, so colons are replaced by hand
function stamp(ts, minutes) {
  let d = new Date(ts);
  let s = d.getFullYear() + "-" + pad2(d.getMonth() + 1) + "-" + pad2(d.getDate()) +
    "T" + pad2(d.getHours()) + ":" + minutes + ":00";
  return s.split(":").join("%3A");
}
function hoursWanted() {
  let n = Math.round(getVc(vHours, 3));
  if (!(n >= 1)) n = 1;
  if (n > 12) n = 12;
  return n;
}
function readyHour() {
  let h = Math.round(getVc(vReady, 7));
  if (!(h >= 0)) h = 0;
  if (h > 23) h = 23;
  return h;
}
// Average price between two hour boundaries, or null if a price is missing
function avgOf(start, end) {
  let i = (start - firstTs) / H;
  let n = (end - start) / H;
  if (i < 0 || i + n > prices.length) return null;
  let sum = 0;
  for (let j = 0; j < n; j++) sum += prices[i + j];
  return round2(sum / n);
}
// Next time the load has to be done. Skips the deadline the last window
// already served, so a window ending at 05:00 does not start a new one before 07:00
function nextDeadline(now) {
  let d = new Date(now);
  let dl = new Date(d.getFullYear(), d.getMonth(), d.getDate(), readyHour(), 0, 0).getTime();
  while (dl <= now || dl <= lastDeadline) dl += 24 * H;
  return dl;
}
function computePlan() {
  let now = Date.now();
  let n = hoursWanted();
  let deadline = nextDeadline(now);
  // The current hour only counts if we are within its first five minutes
  let from = hourStart(now);
  if (now - from > 5 * 60000) from += H;
  let latestStart = deadline - n * H;
  if (latestStart < from) latestStart = from; // Not enough time left: start as soon as possible
  let knownEnd = firstTs + prices.length * H;
  // Tomorrow's prices are published around 13:00. If the window reaches past
  // the known prices and there is still time, wait for them instead of guessing
  if (CONFIG.debug) dbg("compute: now " + dbgTime(now) + ", hours " + n + ", deadline " + dbgTime(deadline) +
    ", from " + dbgTime(from) + ", latestStart " + dbgTime(latestStart) + ", knownEnd " + (knownEnd ? dbgTime(knownEnd) : "none"));
  if (latestStart + n * H > knownEnd && from < latestStart) {
    if (CONFIG.debug) dbg("waiting: the window may end at " + hhmm(latestStart + n * H) +
      ", prices are known until " + (knownEnd ? hhmm(knownEnd) : "none") + ", and there is still time");
    plan = null;
    waiting = true;
    return;
  }
  waiting = false;
  let best = -1;
  let bestAvg = 0;
  let top = [];  // The three cheapest candidates, for debug only
  for (let s = from; s <= latestStart; s += H) {
    let a = avgOf(s, s + n * H);
    if (a !== null && (best < 0 || a < bestAvg)) {
      best = s;
      bestAvg = a;
    }
    if (CONFIG.debug && a !== null) {
      top.push({ s: s, a: a });
      top.sort(function (x, y) { return x.a - y.a; });
      if (top.length > 3) top.pop();
    }
  }
  if (CONFIG.debug) {
    let t = "";
    for (let k = 0; k < top.length; k++) t += hhmm(top[k].s) + "-" + hhmm(top[k].s + n * H) + " " + top[k].a.toFixed(2) + "  ";
    dbg("cheapest candidates: " + (t || "none"));
  }
  if (best < 0) {
    // No usable prices and no time left: run now so the load is still done on time
    print("No prices for the window — starting now as a fallback");
    plan = { start: from, end: from + n * H, avg: null, deadline: deadline };
  } else {
    plan = { start: best, end: best + n * H, avg: bestAvg, deadline: deadline };
  }
  print("Plan: " + hhmm(plan.start) + "-" + hhmm(plan.end) + ", average " + plan.avg + " DKK/kWh");
  if (CONFIG.debug) dbg("chosen: " + dbgTime(plan.start) + " to " + dbgTime(plan.end));
}
function show() {
  if (plan) {
    let text = hhmm(plan.start) + " → " + hhmm(plan.end);
    if (plan.avg !== null) {
      text += " (" + plan.avg.toFixed(2) + " DKK)";
      setVc(vAvg, clampPrice(plan.avg));
    }
    setVc(vPlan, text);
  } else {
    setVc(vPlan, waiting ? "Waiting for tomorrow's prices" : "No plan");
  }
}
// Written only when a window ends, so a restart before the deadline does not run the load again
function saveLastDeadline() {
  if (CONFIG.debug) dbg("KVS write " + KVS_KEY + " = " + lastDeadline + " (" + dbgTime(lastDeadline) + ")");
  Shelly.call("KVS.Set", { key: KVS_KEY, value: lastDeadline }, function (res, code, msg) {
    if (code !== 0) print("Could not save the last deadline: " + msg);
    if (code !== 0 && CONFIG.debug) dbg("KVS write failed: code " + code + ", " + msg);
  });
}
function evaluate() {
  let now = Date.now();
  if (plan && now >= plan.end) {
    lastDeadline = plan.deadline;
    saveLastDeadline();
    plan = null;
  }
  // A window that has started is locked. Anything else is recalculated,
  // so newly published prices are used right away
  if (!(plan && now >= plan.start)) computePlan();
  let on = plan !== null && now >= plan.start && now < plan.end;
  // Only written on changes, so scenes and actions fire once per start and end
  if (on !== wasActive) {
    setVc(vActive, on);
    let was = wasActive;
    wasActive = on;
    print(on ? "Cheap window started" : "Cheap window ended");
    if (CONFIG.debug && on) dbg("window started and locked: " + dbgTime(plan.start) + " to " + dbgTime(plan.end));
    if (CONFIG.debug && !on && was === true) dbg("window ended at " + dbgTime(now));
  }
  show();
}
function safeEvaluate() {
  try {
    evaluate();
  } catch (e) {
    print("Evaluate failed: " + e.message);
  }
}
function onPrices(res, code, msg) {
  try {
    if (CONFIG.debug) dbg("price fetch: rpc code " + code + ", HTTP " + (res ? res.code : "none") +
      ", " + (res && res.body ? res.body.length : 0) + " characters" + (code !== 0 ? ", error " + msg : ""));
    if (code !== 0 || !res || res.code !== 200) {
      print("Price fetch failed: " + (msg || (res ? res.code : "")) + " — keeping the prices already known");
    } else {
      let data = JSON.parse(res.body);
      res = null;
      let list = data.prices ? data.prices : data;
      let p = [];
      let t0 = 0;
      for (let i = 0; i < list.length; i++) {
        let item = list[i];
        let ts = new Date(item.date).getTime();
        let v = typeof item.price === "number" ? item.price : item.price.total;
        if (i === 0) t0 = ts;
        if (ts !== t0 + p.length * H) {
          print("Gap in the price data — using the prices before it");
          break;
        }
        p.push(v + CONFIG.additional_cost);
      }
      data = null;
      list = null;
      if (p.length > 0) {
        prices = p;
        firstTs = t0;
        print("Prices parsed: " + prices.length + " hours");
        print("Prices known until " + hhmm(firstTs + prices.length * H));
        if (CONFIG.debug) {
          dbg(prices.length + " hours in the answer, first " + dbgTime(firstTs) + ", last " + dbgTime(firstTs + (prices.length - 1) * H));
          dbgPrices();
        }
      }
    }
    let i = (hourStart(Date.now()) - firstTs) / H;
    if (i >= 0 && i < prices.length) setVc(vPrice, clampPrice(round2(prices[i])));
  } catch (e) {
    print("Could not read the prices: " + e.message);
    if (CONFIG.debug) dbg("price parse error: " + e.message);
  }
  safeEvaluate();
}
function fetchPrices() {
  let from = hourStart(Date.now());
  let url = "https://stromligning.dk/api/prices?from=" + stamp(from, "00") +
    "&to=" + stamp(from + 35 * H, "45") +
    "&supplierId=" + supplier.id + "&priceArea=" + supplier.area +
    "&aggregation=1h&lean=true";
  if (CONFIG.debug) dbg("fetch " + url);
  Shelly.call("HTTP.GET", { url: url, timeout: 15 }, onPrices);
}
function onSupplier(res, code, msg) {
  try {
    if (CONFIG.debug) dbg("grid company lookup: rpc code " + code + ", HTTP " + (res ? res.code : "none") +
      ", " + (res && res.body ? res.body.length : 0) + " characters" + (code !== 0 ? ", error " + msg : ""));
    if (code !== 0 || !res || res.code !== 200) {
      print("Grid company lookup failed: " + msg);
    } else {
      let list = JSON.parse(res.body);
      if (list && list.length > 0) {
        supplier = { id: list[0].id, area: list[0].priceArea };
        print("Grid company: " + supplier.id + ", price area " + supplier.area);
      } else {
        print("No grid company found for these coordinates — check lat and long");
      }
    }
    if (supplier) {
      fetchPrices();
      return;
    }
  } catch (e) {
    print("Could not read the grid company: " + e.message);
  }
  safeEvaluate();
}
function onTick() {
  try {
    if (supplier) {
      fetchPrices();
    } else {
      let url = "https://stromligning.dk/api/suppliers/find?lat=" + CONFIG.lat + "&long=" + CONFIG.long;
      if (CONFIG.debug) dbg("grid company lookup near lat " + dbgCoord(CONFIG.lat) + ", long " + dbgCoord(CONFIG.long));
      Shelly.call("HTTP.GET", { url: url, timeout: 15 }, onSupplier);
    }
  } catch (e) {
    print("Tick failed: " + e.message);
  }
  scheduleTick();
}
function scheduleTick() {
  let now = Date.now();
  let delay = hourStart(now) + H - now + CONFIG.fetch_delay_seconds * 1000;
  Timer.set(delay, false, onTick);
}
// Changing the hours during a running window extends or shortens it.
// Otherwise the plan is recalculated at once
function onHoursChange(ev) {
  try {
    let now = Date.now();
    if (plan && now >= plan.start) {
      let oldEnd = plan.end;
      plan.end = plan.start + hoursWanted() * H;
      plan.avg = avgOf(plan.start, plan.end);
      if (CONFIG.debug) dbg("running window " + (plan.end > oldEnd ? "extended" : "shortened") + ": " +
        dbgTime(plan.start) + " to " + dbgTime(plan.end) + " (was to " + dbgTime(oldEnd) + ")");
    } else {
      plan = null;
    }
  } catch (e) {
    print("Hours change failed: " + e.message);
  }
  safeEvaluate();
}
// A new deadline takes effect at once, unless a window is running
function onReadyChange(ev) {
  try {
    if (!(plan && Date.now() >= plan.start)) plan = null;
  } catch (e) {
    print("Deadline change failed: " + e.message);
  }
  safeEvaluate();
}
// Puts the six components in the script's own group, so the user only has
// to extract it as a device in the app
function fillGroup() {
  let parts = [["number", vPrice], ["number", vHours], ["number", vReady],
    ["boolean", vActive], ["text", vPlan], ["number", vAvg]];
  let keys = [];
  for (let i = 0; i < parts.length; i++) {
    let c = parts[i][1] ? parts[i][1].getConfig() : null;
    if (c && typeof c.id === "number") keys.push(parts[i][0] + ":" + c.id);
  }
  if (CONFIG.debug) dbg("components " + keys.join(", "));
  let g = vGroup ? vGroup.getConfig() : null;
  if (!g || typeof g.id !== "number") {
    print("Group missing — add the components to a group by hand");
    return;
  }
  Shelly.call("Group.Set", { id: g.id, value: keys }, function (res, code, msg) {
    print(code === 0 ? "Group filled: " + keys.join(", ") : "Could not fill the group: " + msg);
    if (code !== 0 && CONFIG.debug) dbg("Group.Set failed: code " + code + ", " + msg);
  });
}
function onLastDeadline(res, code, msg) {
  try {
    if (code === 0 && res && typeof res.value === "number") lastDeadline = res.value;
    if (CONFIG.debug) dbg("KVS " + KVS_KEY + " = " + (code === 0 && res ? res.value : "not set (code " + code + ")"));
    print("Last deadline served: " + (lastDeadline ? dayHour(lastDeadline) : "none"));
  } catch (e) {
    print("Could not read the last deadline: " + e.message);
  }
  onTick();
}
function start() {
  if (!vHours || !vReady || !vActive || !vPlan || !vAvg || !vPrice) {
    print("Virtual components missing — the device needs firmware 2.0.0 or newer");
    return;
  }
  print("Components found");
  if (CONFIG.debug) {
    try {
      dbgStart();
    } catch (e) {
      dbg("start info failed: " + e.message);
    }
  }
  try {
    fillGroup();
  } catch (e) {
    print("Could not fill the group: " + e.message);
  }
  vHours.on("change", onHoursChange);
  vReady.on("change", onReadyChange);
  Shelly.call("KVS.Get", { key: KVS_KEY }, onLastDeadline);
}
try {
  start();
} catch (e) {
  print("Start failed: " + e.message);
}