/* ev-week.jsx — veckoschema per laddbox (SPEC §12, live i staging 15/8 23:49).
   ────────────────────────────────────────────────────────────────────────
   Sju valfria fält per laddbox: departure_mon … departure_sun, värde "HH:MM"
   eller null. Kontraktets semantik, ordagrant:

     • Minst en satt dag ⇒ VECKOSCHEMAT gäller. Deadline är nästa (dag, tid)
       efter inkopplingen.
     • Inga dagar satta ⇒ som förut: departure_time + departure_day.
     • Per-tillfälle-overriden (ev_session.departure_time) byter TIDEN på nästa
       schemalagda dag — inte dagen. Det syns i vyn, annars ser det ut som att
       dagvalet slutat fungera.
     • I sol-läge räknas en satt veckodag som avresedag ⇒ nätgarantin öppnas,
       precis som departure_day gör. Med sju rader gäller varningen sju rader.
     • Fälten saknas i GET tills någon sparat dem ⇒ saknad nyckel = null.

   Sparas via window.hems.saveSettingsPatch med HELA ev_chargers-listan och
   varje posts samtliga fält — en partiell post nollställer allt backend inte
   fick med. Laddbox-id lämnas orört: kanoniskt id är ev_1, ev_2 (positionen),
   men det gamla evN accepteras fortfarande och att byta det här skulle skilja
   sig från vad resten av appen skriver. */

const EW_DAYS = [
  ['departure_mon','Måndag','mon'], ['departure_tue','Tisdag','tue'],
  ['departure_wed','Onsdag','wed'], ['departure_thu','Torsdag','thu'],
  ['departure_fri','Fredag','fri'], ['departure_sat','Lördag','sat'],
  ['departure_sun','Söndag','sun'],
];
// JS getDay(): 0 = söndag, 1 = måndag … 6 = lördag. EW_DAYS är måndagsstartad,
// så index 0 (måndag) → 1 och index 6 (söndag) → 0.
const EW_JS_DAY = [1, 2, 3, 4, 5, 6, 0];
const EW_HHMM = /^([01]\d|2[0-3]):([0-5]\d)$/;

const ewTimeOk = (v) => !v || EW_HHMM.test(v);
const ewPad = (v) => {
  const m = /^(\d{1,2}):(\d{1,2})$/.exec(String(v || '').trim());
  return m ? String(m[1]).padStart(2,'0')+':'+String(m[2]).padStart(2,'0') : null;
};

/* Nästa deadline ur schemat. Samma regel som backendens deadline-upplösning:
   nästa (dag, tid) efter nu. Visas som text så att användaren ser vad valen
   betyder utan att behöva vänta på en plan. */
function ewNextDeadline(week, now){
  const base = now || new Date();
  let best = null;
  EW_DAYS.forEach(([key], i) => {
    const t = week[key];
    if (!t || !EW_HHMM.test(t)) return;
    const [hh, mm] = t.split(':').map(Number);
    const target = EW_JS_DAY[i];
    const d = new Date(base);
    d.setHours(hh, mm, 0, 0);
    let add = (target - d.getDay() + 7) % 7;
    if (add === 0 && d <= base) add = 7;
    d.setDate(d.getDate() + add);
    if (!best || d < best.at) best = { at: d, dayIdx: i, time: t };
  });
  return best;
}

const ewRel = (dt, now) => {
  const a = new Date(now); a.setHours(0,0,0,0);
  const b = new Date(dt);  b.setHours(0,0,0,0);
  const days = Math.round((b - a)/86400000);
  if (days === 0) return 'idag';
  if (days === 1) return 'i morgon';
  return 'om ' + days + ' dygn';
};

function EvWeek({ charger, index, allChargers, session, name, onSaved }){
  const c = charger || {};
  const now = window.hemsDate ? window.hemsDate() : new Date();

  // Utkast: sju dagar plus det gamla ett-värdet. Saknad nyckel = null.
  const incoming = React.useMemo(() => {
    const w = {};
    EW_DAYS.forEach(([key]) => { w[key] = c[key] || null; });
    return w;
  }, [c]);
  const [draft, setDraft] = React.useState(null);
  const [toast, setToast] = React.useState(null);
  const w = draft || incoming;
  const dirty = !!draft;

  const anySet = EW_DAYS.some(([key]) => !!w[key]);
  const solarMode = c.solar_mode === true;
  const next = React.useMemo(() => anySet ? ewNextDeadline(w, now) : null, [w, anySet, now]);
  const invalid = EW_DAYS.filter(([key]) => w[key] && !ewTimeOk(w[key]));

  const set = (key, val) => setDraft({ ...w, [key]: val === '' ? null : val });
  const clearAll = () => setDraft(EW_DAYS.reduce((a,[k]) => ({ ...a, [k]: null }), {}));
  const fillAll = () => {
    const first = EW_DAYS.map(([k]) => w[k]).find(Boolean) || c.departure_time || '07:00';
    setDraft(EW_DAYS.reduce((a,[k]) => ({ ...a, [k]: first }), {}));
  };
  const weekdaysOnly = () => {
    const first = EW_DAYS.map(([k]) => w[k]).find(Boolean) || c.departure_time || '07:00';
    setDraft(EW_DAYS.reduce((a,[k],i) => ({ ...a, [k]: i < 5 ? first : null }), {}));
  };

  const save = async () => {
    if (invalid.length){ setToast({ kind:'err', msg:'Tiden måste vara HH:MM' }); return; }
    const patch = {};
    EW_DAYS.forEach(([key]) => {
      const v = w[key] ? ewPad(w[key]) : null;
      if ((v || null) !== (c[key] || null)) patch[key] = v;
    });
    if (!Object.keys(patch).length){ setDraft(null); return; }
    try {
      setToast({ kind:'info', msg:'Sparar…' });
      await window.hems.saveSettingsPatch((full) => {
        const list = Array.isArray(full?.ev_chargers) ? full.ev_chargers : null;
        if (!list || !list.length) throw new Error('Laddboxlistan saknas i inställningarna');
        // Matcha på POSITION — kanoniskt id är positionen, och råa id-strängen
        // kan vara legacy (ev0 mot ev_1). Faller tillbaka på id om listan
        // skulle ha ändrat ordning mellan läsning och sparning.
        let k = (index != null && index < list.length) ? index : -1;
        if (k >= 0 && c.id != null && list[k] && String(list[k].id) !== String(c.id)){
          const byId = list.findIndex(x => String(x?.id) === String(c.id));
          if (byId >= 0) k = byId;
        }
        if (k < 0) throw new Error('Hittar inte laddboxen i inställningarna');
        return { ev_chargers: list.map((x, i) => i === k ? { ...x, ...patch } : x) };
      });
      setDraft(null);
      setToast({ kind:'ok', msg:'Sparat — planeras om inom ~15 min' });
      if (onSaved) onSaved();
    } catch (e) {
      setToast({ kind:'err', msg: String(e && e.message || e) });
    }
  };

  React.useEffect(() => {
    if (!toast || toast.kind === 'info') return;
    const id = setTimeout(() => setToast(null), 4000);
    return () => clearTimeout(id);
  }, [toast]);

  const sessTime = session?.departure_time || null;
  const overridden = anySet && next && sessTime && sessTime !== next.time;

  return (
    <div className={`ew-card${dirty ? ' dirty' : ''}`}>
      <div className="ew-hd">
        <div>
          <div className="ew-t">Avresetider · {name || 'Laddbox'}</div>
          <div className="ew-s">{anySet
            ? 'Veckoschemat gäller. Bilen ska vara klar till tiden på nästa satt dag.'
            : 'Inget veckoschema satt — avresetiden under Laddinställningar gäller.'}</div>
        </div>
        <div className="ew-quick">
          <button type="button" onClick={fillAll}>Alla dagar</button>
          <button type="button" onClick={weekdaysOnly}>Vardagar</button>
          <button type="button" onClick={clearAll} disabled={!anySet}>Rensa</button>
        </div>
      </div>

      {/* Ett-värdesläget (§12: rita båda lägena i samma vy). Utan den här raden
          gick effektiv deadline inte att läsa i det läge kortet startar i —
          varje befintligt hushåll har alla sju nycklar tomma. */}
      {!anySet && (
        <div className="ew-single">
          <span className="ew-single-l">Gäller nu</span>
          <b>{c.departure_time || '—'}</b>
          <span>{c.departure_day
            ? (EW_DAYS.find(([,,k]) => k === c.departure_day)?.[1] || c.departure_day).toLowerCase()
            : (solarMode ? 'ingen avresedag — bara sol' : 'varje dag')}</span>
        </div>
      )}

      <div className="ew-rows">
        {EW_DAYS.map(([key, label], i) => {
          const on = !!w[key];
          const isNext = next && next.dayIdx === i;
          return (
            <div className={`ew-row${on ? ' on' : ''}${isNext ? ' next' : ''}`} key={key}>
              <button type="button" className="ew-chk" aria-pressed={on}
                onClick={()=>set(key, on ? '' : (EW_DAYS.map(([k])=>w[k]).find(Boolean) || c.departure_time || '07:00'))}>
                <i/>{label}
              </button>
              {on ? (
                <span className={`ew-time${ewTimeOk(w[key]) ? '' : ' bad'}`}>
                  <input type="time" value={w[key]} onChange={(e)=>set(key, e.target.value)}/>
                </span>
              ) : (
                <span className="ew-off">ingen avresa</span>
              )}
              {isNext && <span className="ew-next">nästa</span>}
            </div>
          );
        })}
      </div>

      {anySet && next && (
        <div className="ew-deadline">
          Nästa deadline: <b>{EW_DAYS[next.dayIdx][1].toLowerCase()} {next.time}</b>
          <span> ({ewRel(next.at, now)})</span>
        </div>
      )}

      {/* Overriden byter TIDEN på nästa schemalagda dag, aldrig dagen. Utan
          den här raden ser det ut som att dagvalet slutat gälla. */}
      {overridden && (
        <div className="ew-note">
          Den här gången gäller <b>{sessTime}</b> i stället, från snabbjusteringen.
          Dagen ändras inte — nästa avresa är fortfarande {EW_DAYS[next.dayIdx][1].toLowerCase()}.
        </div>
      )}

      {/* Sol-läge: satt veckodag öppnar nätgarantin, samma regel som
          departure_day. Med sju rader gäller varningen sju rader. */}
      {solarMode && (
        <div className={`ew-note${anySet ? ' warn' : ''}`}>
          {anySet
            ? <React.Fragment>Laddboxen är inställd på sol. Eftersom minst en avresedag är satt köper
              HEMS <b>nätel</b> när solen inte räcker fram till den tiden.</React.Fragment>
            : 'Laddboxen är inställd på sol och laddas bara ur solöverskott. Sätter du en avresetid här köps nätel in när solen inte räcker.'}
        </div>
      )}

      {invalid.length > 0 && (
        <div className="ew-note warn">Tiden måste skrivas som HH:MM, till exempel 07:30.</div>
      )}

      <div className="ew-foot">
        {toast && <span className={`ew-toast ${toast.kind}`}>{toast.msg}</span>}
        <button type="button" className={`ew-save${dirty ? ' attn' : ''}`} disabled={!dirty} onClick={save}>Spara</button>
        {dirty && <button type="button" className="ew-undo" onClick={()=>{ setDraft(null); setToast(null); }}>Ångra</button>}
      </div>
    </div>
  );
}

function EvWeekCards({ settings, live, session, onSaved }){
  const chargers = window.evModel?.normalize ? window.evModel.normalize(settings) : [];
  if (!chargers.length) return null;
  return (
    <div className="ew-wrap">
      {chargers.map((c, i) => (
        <EvWeek key={c.id ?? i} charger={c} index={i} allChargers={chargers}
          name={window.evModel?.displayName ? window.evModel.displayName(c, i) : (c.name || 'Laddbox '+(i+1))}
          session={window.evModel?.sessionFor ? window.evModel.sessionFor(settings, c, i) : session}
          onSaved={onSaved}/>
      ))}
    </div>
  );
}

Object.assign(window, { EvWeek, EvWeekCards, ewNextDeadline });