// ===== Componentes del seguimiento =====
const { useState, useEffect, useRef } = React;

// --- Input común ---
function Field({ label, value, onChange, placeholder, type = 'text', suffix, small }) {
  return (
    <div className="field">
      <label>{label}{suffix ? <span style={{ color: 'var(--ink-3)', marginLeft: 6, letterSpacing: 0 }}>· {suffix}</span> : ''}</label>
      <input
        type={type}
        value={value || ''}
        onChange={e => onChange(e.target.value)}
        placeholder={placeholder || ''}
        style={small ? { padding: '10px 12px', fontSize: 13 } : {}}
      />
    </div>
  );
}

// --- Selector de foto ---
function PhotoSlot({ value, onChange, label, subtitle }) {
  const inputRef = useRef(null);
  const onFile = (e) => {
    const f = e.target.files && e.target.files[0];
    if (!f) return;
    const reader = new FileReader();
    reader.onload = () => onChange(reader.result);
    reader.readAsDataURL(f);
  };
  return (
    <>
      <div
        className={"photo-upload" + (value ? " filled" : "")}
        onClick={() => inputRef.current && inputRef.current.click()}
        style={value ? { backgroundImage: `url(${value})`, backgroundSize: 'cover', backgroundPosition: 'center' } : {}}
      >
        {!value && <>
          <div className="pu-icon">+</div>
          <div className="pu-title">{label}</div>
          <div className="pu-desc">{subtitle}</div>
        </>}
        {value && <div style={{ background: 'rgba(255,255,255,0.9)', padding: '8px 14px', borderRadius: 8, fontFamily: 'Inter, -apple-system, sans-serif', fontSize: 10, letterSpacing: '0.15em', textTransform: 'uppercase', color: 'var(--rose-deep)' }}>Cambiar foto</div>}
      </div>
      <input type="file" accept="image/*" ref={inputRef} onChange={onFile} style={{ display: 'none' }} />
    </>
  );
}

// --- Portada / Home ---
function HomeScreen({ state, setState }) {
  const done = daysCompleted(state);
  const total = TRACK_CONFIG.totalDays;
  const pct = Math.min(100, Math.round((done / total) * 100));
  const C = 2 * Math.PI * 90;
  const offset = C - (pct / 100) * C;

  const unlocked = done >= TRACK_CONFIG.unlockDay;

  return (
    <div data-screen-label="Seguimiento — Home">
      <div style={{ marginBottom: 40 }}>
        <span className="eyebrow">Tu diario · 12 semanas</span>
        <h1 className="h1" style={{ fontSize: 64, marginTop: 14, lineHeight: 1.02 }}>
          {state.userName ? <>Hola, <em>{state.userName}</em></> : <>Tu <em>camino</em></>}
        </h1>
        <p className="lead" style={{ maxWidth: '56ch', marginTop: 18 }}>
          Aquí vas a registrar tu día a día — peso, medidas, comidas y cómo te sientes.
          No es para juzgarte, es para que dentro de 84 días veas de dónde vienes.
        </p>
      </div>

      <div className="progress-hero">
        <div className="ring-wrap">
          <svg viewBox="0 0 200 200">
            <circle className="ring-bg" cx="100" cy="100" r="90" />
            <circle className="ring-fg" cx="100" cy="100" r="90"
              strokeDasharray={C} strokeDashoffset={offset} />
          </svg>
          <div className="ring-center">
            <div className="ring-num">{done}<em>/{total}</em></div>
            <div className="ring-label">Días registrados</div>
          </div>
        </div>
        <div>
          <h3 className="h3" style={{ marginBottom: 10 }}>{pct}% del camino</h3>
          <p className="body" style={{ maxWidth: '46ch', marginBottom: 18 }}>
            Cada día que registras suma. No hace falta que sean perfectos — solo reales.
            Cuando llegues a los <strong>84 días</strong> desbloquearás la última pestaña con algo preparado para ti.
          </p>
          <button
            className="btn"
            onClick={() => setState(s => ({ ...s, view: { screen: 'day', day: currentDayNumber(s) } }))}
            style={{ background: 'var(--rose-deep)', color: 'var(--cream)', border: 'none', padding: '12px 22px', borderRadius: 10, fontFamily: 'Inter, sans-serif', fontWeight: 600, cursor: 'pointer', fontSize: 13, letterSpacing: '0.03em' }}
          >
            Registrar el día de hoy →
          </button>
        </div>
      </div>

      <SetupBlock state={state} setState={setState} />

      <h3 className="h3" style={{ marginTop: 50, marginBottom: 18 }}>Hitos del camino</h3>
      <div className="milestones">
        {TRACK_CONFIG.milestones.map(m => (
          <div key={m.day} className={"milestone" + (done >= m.day ? " reached" : "")}>
            <div className="m-day">{m.day}</div>
            <div>
              <div className="m-title">{m.title}</div>
              <div className="m-desc">{m.desc}</div>
            </div>
          </div>
        ))}
      </div>
    </div>
  );
}

function SetupBlock({ state, setState }) {
  const update = (k, v) => setState(s => ({ ...s, [k]: v }));

  return (
    <div className="setup-card" style={{ marginTop: 36 }}>
      <div className="setup-left">
        <h3>Empecemos por el principio</h3>
        <p>Tu fecha de inicio, tus objetivos de <em>kcal y proteína</em> (te los calcula TuGPT) y una foto tal como estás hoy. La foto queda solo en este dispositivo.</p>
        <Field label="Tu nombre" value={state.userName} onChange={v => update('userName', v)} placeholder="Cómo te llamas" />
        <Field label="Fecha de inicio" type="date" value={state.startDate} onChange={v => update('startDate', v)} />
        <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 12 }}>
          <Field label="Kcal objetivo" suffix="kcal/día" value={state.targetKcal} onChange={v => update('targetKcal', v)} placeholder="1800" />
          <Field label="Proteína objetivo" suffix="g/día" value={state.targetProtein} onChange={v => update('targetProtein', v)} placeholder="120" />
        </div>
        <div
          onClick={() => setState(s => ({ ...s, view: { ...s.view, screen: 'ai' } }))}
          style={{
            marginTop: 14, cursor: 'pointer',
            fontFamily: 'Fraunces, serif', fontStyle: 'italic',
            fontSize: 14, color: 'var(--rose-deep)',
            display: 'inline-flex', alignItems: 'center', gap: 6
          }}
        >
          ¿No los sabes? <span style={{ fontWeight: 500, borderBottom: '1px solid var(--rose-deep)' }}>Créalos con TuGPT</span> →
        </div>
      </div>
      <PhotoSlot
        value={state.photoBefore}
        onChange={v => update('photoBefore', v)}
        label="Foto antes"
        subtitle="Ropa interior o deportiva. Luz natural si puedes. Nadie la verá salvo tú."
      />
    </div>
  );
}

// --- Vasitos de agua: click para sumar 250ml, click de nuevo para quitar ---
function WaterGlasses({ value, onChange }) {
  // value in L; 250ml = 0.25L
  const TARGET_ML = 2000;
  const filled = Math.round((value || 0) * 1000 / 250);
  const GLASSES_SHOWN = Math.max(8, filled + 1); // siempre hay un vaso vacío siguiente
  const glasses = Math.min(GLASSES_SHOWN, 12);

  const toggle = (idx) => {
    // si clicko el siguiente vacío: sumar 250
    // si clicko uno ya lleno: volver a ese nivel (recortar)
    const newFilled = idx < filled ? idx : idx + 1;
    onChange(newFilled * 0.25);
  };

  const totalMl = filled * 250;
  return (
    <div className="water-glasses-wrap">
      <div className="wg-grid">
        {Array.from({ length: glasses }).map((_, i) => {
          const isFilled = i < filled;
          const isNext = i === filled;
          return (
            <button
              key={i}
              className={"wg-cup" + (isFilled ? " filled" : "") + (isNext ? " next" : "")}
              onClick={() => toggle(i)}
              type="button"
              aria-label={isFilled ? `Vaso ${i+1} lleno` : 'Añadir vaso'}
            >
              <svg viewBox="0 0 40 50" width="32" height="40">
                <path d="M7 6 L33 6 L30 45 Q30 47 28 47 L12 47 Q10 47 10 45 Z"
                  fill={isFilled ? 'var(--rose-soft)' : 'none'}
                  stroke="var(--rose-deep)" strokeWidth="1.5" strokeLinejoin="round" />
                {isFilled && (
                  <path d="M9 18 Q14 16 20 18 T31 18 L29 45 Q29 46 27 46 L13 46 Q11 46 11 45 Z"
                    fill="var(--rose-deep)" opacity="0.55" />
                )}
                {isNext && (
                  <text x="20" y="30" textAnchor="middle"
                    fontSize="16" fontFamily="Fraunces, serif" fontWeight="300"
                    fill="var(--rose-deep)">+</text>
                )}
              </svg>
              <span className="wg-ml">250 ml</span>
            </button>
          );
        })}
      </div>
      <div className="wg-total">
        <span className="wg-total-num">{(totalMl / 1000).toFixed(2).replace('.', ',')}<em>L</em></span>
        <span className="wg-total-label">de {(TARGET_ML/1000).toFixed(1).replace('.',',')}L objetivo</span>
      </div>
    </div>
  );
}

// --- Día ---
function DayScreen({ state, setState }) {
  const n = state.view.day;
  const day = state.days[n] || DEFAULT_DAY();
  const total = TRACK_CONFIG.totalDays;
  const motivation = TRACK_CONFIG.motivations[(n - 1) % TRACK_CONFIG.motivations.length];

  const updateDay = (patch) => setState(s => ({
    ...s,
    days: { ...s.days, [n]: { ...DEFAULT_DAY(), ...(s.days[n] || {}), ...patch } }
  }));
  const updateMeal = (mealKey, patch) => setState(s => {
    const prev = s.days[n] || DEFAULT_DAY();
    const meals = { ...prev.meals, [mealKey]: { ...prev.meals[mealKey], ...patch } };
    return { ...s, days: { ...s.days, [n]: { ...prev, meals } } };
  });

  const totals = sumDay(day);

  const goto = (delta) => {
    const next = Math.max(1, Math.min(total, n + delta));
    setState(s => ({ ...s, view: { ...s.view, day: next } }));
  };

  const dateFor = (() => {
    if (!state.startDate) return null;
    const d = new Date(state.startDate);
    d.setDate(d.getDate() + (n - 1));
    return d.toLocaleDateString('es-ES', { weekday: 'long', day: 'numeric', month: 'long' });
  })();

  return (
    <div data-screen-label={`Día ${n}`}>
      <div className="day-head">
        <div>
          <div className="day-eyebrow">Día {n} de {total} · Semana {Math.ceil(n / 7)}</div>
          <h2>Mi <em>día</em></h2>
          {dateFor && <div className="day-date">{dateFor.charAt(0).toUpperCase() + dateFor.slice(1)}</div>}
        </div>
        <div className="motivation">“{motivation}”</div>
      </div>

      <div className="date-nav" style={{ marginBottom: 28, display: 'inline-flex' }}>
        <button onClick={() => goto(-1)} disabled={n <= 1}>← Día anterior</button>
        <span className="current">Día {n}</span>
        <button onClick={() => goto(1)} disabled={n >= total}>Día siguiente →</button>
      </div>

      {/* Métricas rápidas */}
      <div className="group-header">
        <h3 className="h3">Cómo amaneciste</h3>
        <span className="group-count">01 · MÉTRICAS</span>
      </div>
      <div className="log-grid">
        <div className="log-card">
          <div className="log-head"><h4>Peso de hoy</h4><span className="log-ico">◉</span></div>
          <div className="log-row">
            <Field label="Peso" suffix="kg" value={day.weight} onChange={v => updateDay({ weight: v })} placeholder="0,0" small />
          </div>
          <p style={{ fontSize: 12, color: 'var(--ink-3)', marginTop: 8, lineHeight: 1.45 }}>
            Mídete en ayunas, sin ropa, siempre el mismo día a la misma hora. Un solo número, sin drama.
          </p>
        </div>
        <div className="log-card">
          <div className="log-head"><h4>Agua</h4><span className="log-ico">◇</span></div>
          <WaterGlasses value={parseFloat(day.water) || 0} onChange={v => updateDay({ water: v.toFixed(2) })} />
        </div>
      </div>
      <div className="log-grid" style={{ marginTop: 14 }}>
        <div className="log-card">
          <div className="log-head"><h4>Movimiento (al final del día)</h4><span className="log-ico">➞</span></div>
          <div className="log-row">
            <Field label="Pasos" value={day.steps} onChange={v => updateDay({ steps: v })} placeholder="12.000" small />
          </div>
          <label style={{ display: 'flex', gap: 10, alignItems: 'center', fontSize: 14, color: 'var(--ink)', cursor: 'pointer', marginTop: 10, fontWeight: 500 }}>
            <input type="checkbox" checked={day.trained} onChange={e => updateDay({ trained: e.target.checked })} style={{ width: 18, height: 18, accentColor: 'var(--rose-deep)' }} />
            Entrené hoy
          </label>
        </div>
      </div>

      {/* Comidas */}
      <div className="group-header" style={{ marginTop: 30 }}>
        <h3 className="h3">Qué comiste</h3>
        <span className="group-count">02 · ALIMENTACIÓN</span>
      </div>
      <p style={{ fontSize: 13, color: 'var(--ink-3)', marginBottom: 18, maxWidth: '62ch', lineHeight: 1.5 }}>
        Solo las calorías totales y la proteína por comida — lo demás viene solo si esto lo cuidas.
      </p>
      <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
        {MEAL_META.map(m => {
          const meal = day.meals[m.key] || {};
          return (
            <div className="meal-card" key={m.key}>
              <div className="meal-head">
                <span className="meal-title"><span className="meal-ico">{m.ico}</span> {m.label}</span>
                <span className="meal-kcal-sum">{meal.kcal ? <><strong>{meal.kcal}</strong> kcal</> : '—'}</span>
              </div>
              <div className="meal-inputs" style={{ gridTemplateColumns: 'repeat(2, 1fr)' }}>
                <Field label="Kcal" value={meal.kcal} onChange={v => updateMeal(m.key, { kcal: v })} placeholder="0" small />
                <Field label="Proteína" suffix="g" value={meal.p} onChange={v => updateMeal(m.key, { p: v })} placeholder="0" small />
              </div>
            </div>
          );
        })}
      </div>

      <div className="day-totals">
        <div className="day-total"><div className="t-k">Kcal del día</div><div className="t-v"><em>{Math.round(totals.kcal)}</em></div></div>
        <div className="day-total"><div className="t-k">Proteína</div><div className="t-v">{Math.round(totals.p)}<span style={{ fontSize: 16, color: 'var(--ink-3)' }}>g</span></div></div>
      </div>
    </div>
  );
}

// --- Historial ---
function HistoryScreen({ state, setState }) {
  const total = TRACK_CONFIG.totalDays;
  const targetK = parseFloat(state.targetKcal) || null;
  const targetP = parseFloat(state.targetProtein) || null;
  const startDate = state.startDate ? new Date(state.startDate) : null;

  const dateFor = (n) => startDate
    ? new Date(startDate.getTime() + (n - 1) * 86400000).toLocaleDateString('es-ES', { day: '2-digit', month: 'short' })
    : '—';

  // color para kcal: verde si <= objetivo, rojo si pasa
  const kcalClass = (k) => { if (!k || !targetK) return ''; return k <= targetK ? 'cell-good' : 'cell-bad'; };
  // color para prote: verde si >= objetivo, rojo si no llega
  const proClass  = (p) => { if (!p || !targetP) return ''; return p >= targetP ? 'cell-good' : 'cell-bad'; };
  // pasos: verde si >= 12000, rojo si menos (solo si hay dato)
  const stepsClass = (s) => { const v = parseFloat(s); if (!v) return ''; return v >= 12000 ? 'cell-good' : 'cell-bad'; };

  // Construimos filas: día, día,... cada 7 días intercalamos resumen semanal
  const rows = [];
  for (let w = 1; w <= Math.ceil(total / 7); w++) {
    const weekStart = (w - 1) * 7 + 1;
    const weekEnd = Math.min(w * 7, total);
    for (let n = weekStart; n <= weekEnd; n++) {
      rows.push({ kind: 'day', n });
    }
    // resumen de la semana completa
    if (weekEnd >= weekStart) rows.push({ kind: 'week', w, weekStart, weekEnd });
  }

  // calculo de resumen semanal
  const weekSummary = (weekStart, weekEnd) => {
    const ds = [];
    for (let i = weekStart; i <= weekEnd; i++) {
      const d = state.days[i];
      if (d) ds.push(d);
    }
    if (!ds.length) return null;
    const weights = ds.map(d => parseFloat(d.weight)).filter(v => !isNaN(v));
    const avgWeight = weights.length ? (weights.reduce((a,b) => a+b, 0) / weights.length).toFixed(1) : null;
    const withMeals = ds.filter(d => Object.values(d.meals || {}).some(m => m.kcal));
    const avgKcal = withMeals.length ? Math.round(withMeals.reduce((a,d) => a + sumDay(d).kcal, 0) / withMeals.length) : null;
    const avgP    = withMeals.length ? Math.round(withMeals.reduce((a,d) => a + sumDay(d).p, 0) / withMeals.length) : null;
    const steps = ds.map(d => parseFloat(d.steps)).filter(v => !isNaN(v));
    const avgSteps = steps.length ? Math.round(steps.reduce((a,b) => a+b, 0) / steps.length) : null;
    const trainedCount = ds.filter(d => d.trained).length;
    return { avgWeight, avgKcal, avgP, avgSteps, trainedCount, daysLogged: ds.length };
  };

  return (
    <div data-screen-label="Historial">
      <span className="eyebrow">Tu recorrido</span>
      <h2 className="h1" style={{ fontSize: 54, marginTop: 14, marginBottom: 12 }}>
        Historial <em>completo</em>
      </h2>
      <p className="lead group-intro">
        Cada fila es un día — pulsa para editarlo. Al cerrar cada semana verás el resumen con promedios.
        <strong> Verde</strong> = cumpliste el objetivo, <strong style={{ color: '#C94A4A' }}>rojo</strong> = te pasaste o te quedaste corta.
        {(!targetK || !targetP) && <span style={{ display: 'block', marginTop: 8, color: 'var(--rose-deep)' }}>⚠ Configura tus objetivos de kcal y proteína en la portada para ver los colores.</span>}
      </p>

      <div className="hist-table-wrap"><table className="hist-table">
        <thead>
          <tr>
            <th style={{ width: 70 }}>Día</th>
            <th>Fecha</th>
            <th>Peso</th>
            <th>Kcal</th>
            <th>Proteína</th>
            <th>Pasos</th>
            <th style={{ width: 90, textAlign: 'center' }}>Entreno</th>
          </tr>
        </thead>
        <tbody>
          {rows.map((r, idx) => {
            if (r.kind === 'day') {
              const n = r.n;
              const d = state.days[n];
              const filled = d && (d.weight || d.steps || d.trained || Object.values(d.meals || {}).some(m => m && (m.kcal || m.p)));
              const k = d ? Math.round(sumDay(d).kcal) : 0;
              const p = d ? Math.round(sumDay(d).p) : 0;
              const stepsVal = d && d.steps ? parseFloat(d.steps) : 0;
              return (
                <tr key={`d${n}`} className={!filled ? 'empty' : ''} onClick={() => setState(s => ({ ...s, view: { screen: 'day', day: n } }))}>
                  <td className="h-day">D{String(n).padStart(2, '0')}</td>
                  <td>{dateFor(n)}</td>
                  <td>{d && d.weight ? `${d.weight} kg` : '—'}</td>
                  <td className={"h-kcal " + kcalClass(k)}>{k || '—'}</td>
                  <td className={proClass(p)}>{p ? `${p} g` : '—'}</td>
                  <td className={stepsClass(stepsVal)}>{stepsVal ? stepsVal.toLocaleString('es-ES') : '—'}</td>
                  <td style={{ textAlign: 'center', fontSize: 18 }}>
                    {d && d.trained
                      ? <span style={{ color: '#2D8F5C' }}>✓</span>
                      : <span style={{ color: '#C94A4A' }}>✗</span>}
                  </td>
                </tr>
              );
            }
            // resumen semanal
            const s = weekSummary(r.weekStart, r.weekEnd);
            if (!s) return (
              <tr key={`w${r.w}`} className="week-row empty">
                <td className="h-day">S{r.w}</td>
                <td colSpan="6" style={{ fontStyle: 'italic', color: 'var(--ink-3)' }}>Sin datos esta semana</td>
              </tr>
            );
            return (
              <tr key={`w${r.w}`} className="week-row">
                <td className="h-day">S{r.w}</td>
                <td style={{ fontFamily: 'Fraunces, serif', fontStyle: 'italic' }}>Promedio</td>
                <td>{s.avgWeight ? `${s.avgWeight} kg` : '—'}</td>
                <td className={"h-kcal " + kcalClass(s.avgKcal)}>{s.avgKcal || '—'}</td>
                <td className={proClass(s.avgP)}>{s.avgP ? `${s.avgP} g` : '—'}</td>
                <td className={stepsClass(s.avgSteps)}>{s.avgSteps ? s.avgSteps.toLocaleString('es-ES') : '—'}</td>
                <td style={{ textAlign: 'center', fontFamily: 'Fraunces, serif' }}>
                  <span style={{ color: s.trainedCount >= 5 ? '#2D8F5C' : (s.trainedCount >= 3 ? 'var(--rose-deep)' : '#C94A4A') }}>
                    {s.trainedCount}/{r.weekEnd - r.weekStart + 1}
                  </span>
                </td>
              </tr>
            );
          })}
        </tbody>
      </table></div>
    </div>
  );
}

// --- TuGPT — GymStarter, el coach ya hecho ---
const GYMSTARTER_URL = "https://chatgpt.com/g/g-6a1c06147d9c819186e296252e210727-gymstarter";

function AIScreen({ state }) {
  return (
    <div data-screen-label="TuGPT">
      <span className="eyebrow">Tu coach, a un clic</span>
      <h2 className="h1" style={{ fontSize: 60, marginTop: 14, marginBottom: 18, lineHeight: 1.02 }}>
        Gym<em>Starter</em>
      </h2>
      <p className="lead" style={{ maxWidth: '64ch', marginBottom: 18 }}>
        Convierte ChatGPT en tu coach fitness personal para estas 12 semanas. GymStarter te ayuda a
        calcular calorías y macros, registrar comidas, analizar fotos de platos y resolver dudas de
        entrenamiento y alimentación en segundos.
      </p>
      <p className="lead" style={{ maxWidth: '64ch', marginBottom: 22 }}>
        Háblale como si fuera una persona normal: envíale lo que comes, pregúntale qué pedir fuera,
        pídele ideas de comidas o revisa cuánto llevas en el día. Rápido, práctico y sin complicarte
        con nutrición avanzada.
      </p>

      <a
        href={GYMSTARTER_URL}
        target="_blank"
        rel="noopener noreferrer"
        className="gpt-cta"
      >
        Abrir GymStarter
        <span className="gpt-cta-arrow">→</span>
      </a>
      <div className="gpt-devices">Disponible en móvil · ordenador · app de ChatGPT</div>

      {/* Primera vez */}
      <div className="group-header" style={{ marginTop: 48 }}>
        <h3 className="h3">La primera vez</h3>
        <span className="group-count">3 PASOS</span>
      </div>
      <div className="gpt-steps">
        <div className="gpt-step">
          <div className="step-num">01</div>
          <div>
            <h4>Ábrelo y dile que quieres empezar</h4>
            <p>Pulsa <em>“Empezar mi seguimiento”</em> o simplemente escribe <em>“Quiero empezar”</em>.</p>
          </div>
        </div>
        <div className="gpt-step">
          <div className="step-num">02</div>
          <div>
            <h4>Te preguntará lo básico</h4>
            <p>Edad, altura, peso y nivel de actividad. Nada más — en un par de mensajes lo tiene.</p>
          </div>
        </div>
        <div className="gpt-step">
          <div className="step-num">03</div>
          <div>
            <h4>Te calcula tus objetivos</h4>
            <p>Automáticamente te da tus <strong>calorías, proteína, grasas y carbohidratos</strong>.
            Cópialos en la portada de Seguimiento y el historial empezará a pintarse en verde y rojo.</p>
          </div>
        </div>
      </div>

      {/* Qué puedes hacer */}
      <div className="group-header" style={{ marginTop: 40 }}>
        <h3 className="h3">Qué puedes hacer cada día</h3>
      </div>
      <div className="use-grid">
        <div className="use-card">
          <div className="use-ico">✎</div>
          <h4>Registrar comidas</h4>
          <p>Escríbele lo que comes, en lenguaje normal:</p>
          <ul className="use-ex">
            <li>“2 huevos y 3 tostadas”</li>
            <li>“200 g de pollo + arroz”</li>
            <li>“Hoy desayuné café y una arepa”</li>
          </ul>
          <p className="use-foot">Te devuelve kcal, proteína, carbohidratos, grasas y el total del día.</p>
        </div>
        <div className="use-card">
          <div className="use-ico">◳</div>
          <h4>Analizar fotos de comida</h4>
          <p>Envíale una foto directamente — platos, restaurante, snacks, bebidas, comida rápida.</p>
          <p className="use-foot">Estima calorías, macros y porciones aproximadas. Cuanto más clara la foto, más preciso.</p>
        </div>
      </div>

      {/* Preguntas */}
      <div className="gpt-examples" style={{ marginTop: 32 }}>
        <h4>Preguntas que le puedes hacer</h4>
        <ul>
          <li>“¿Cuántas kcal llevo hoy?”</li>
          <li>“¿Qué puedo cenar alto en proteína?”</li>
          <li>“¿Cómo llego a mis macros?”</li>
          <li>“¿Qué pido en McDonald’s?”</li>
          <li>“Dame una cena de menos de 600 kcal”</li>
          <li>“¿Cómo compenso si me pasé ayer?”</li>
          <li>“¿Qué snack me recomiendas?”</li>
          <li>“No me gusta el brócoli, dame alternativas”</li>
        </ul>
      </div>

      {/* Importante + consejo */}
      <div className="gpt-notes">
        <div className="gpt-note">
          <div className="gn-label">Importante</div>
          <p>GymStarter <strong>no sustituye</strong> a médicos ni nutricionistas. Es una guía práctica
          del día a día, rápida y fácil. No necesitas saber de macros: úsalo como un chat normal.</p>
        </div>
        <div className="gpt-note accent">
          <div className="gn-label">El consejo que más funciona</div>
          <p>Quien mejores resultados consigue registra a diario, pesa la comida de vez en cuando para
          aprender porciones, y abre el GPT todos los días aunque sea 2 minutos.
          <strong> La constancia vale más que hacerlo perfecto.</strong></p>
        </div>
      </div>
    </div>
  );
}

// --- Pestaña bloqueada / revelación ---
function LockedScreen({ state }) {
  const done = daysCompleted(state);
  const total = TRACK_CONFIG.totalDays;
  return (
    <div className="locked-screen" data-screen-label="Bloqueado">
      <div className="big-lock">✦</div>
      <h2>Aún <em>no es el momento</em></h2>
      <p>Esta pestaña se desbloquea cuando registres los {total} días de tu programa. Sigue tu camino y nos vemos aquí.</p>
      <div className="locked-progress">{done} / {total} DÍAS</div>
    </div>
  );
}

function RevealScreen({ state, setState }) {
  const [photoAfter, setPhotoAfter] = useState(state.photoAfter || '');
  const [confirming, setConfirming] = useState(false);

  const restartReto = () => {
    try { localStorage.setItem('gymsis:entrenos:done', '{}'); } catch (e) {}
    setState(s => ({
      startDate: '',
      userName: s.userName || '',
      targetKcal: '',
      targetProtein: '',
      photoBefore: '',
      photoAfter: '',
      days: {},
      journal: [],
      view: { screen: 'home', day: 1 },
    }));
  };
  useEffect(() => {
    if (photoAfter !== state.photoAfter) {
      // guardar cuando se suba la foto después
    }
  }, [photoAfter]);

  const totalEntries = Object.keys(state.days).length;
  const trainedCount = Object.values(state.days).filter(d => d && d.trained).length;
  const avgKcal = (() => {
    const days = Object.values(state.days).filter(d => d && Object.values(d.meals || {}).some(m => m.kcal));
    if (!days.length) return 0;
    const sum = days.reduce((a, d) => a + sumDay(d).kcal, 0);
    return Math.round(sum / days.length);
  })();
  const firstWeight = (() => { for (let i = 1; i <= 84; i++) { const d = state.days[i]; if (d && d.weight) return parseFloat(d.weight); } return null; })();
  const lastWeight = (() => { for (let i = 84; i >= 1; i--) { const d = state.days[i]; if (d && d.weight) return parseFloat(d.weight); } return null; })();
  const weightChange = (firstWeight != null && lastWeight != null) ? (lastWeight - firstWeight).toFixed(1) : '—';

  return (
    <div data-screen-label="Revelación">
      <div className="reveal-hero">
        <span className="eyebrow">Lo conseguiste</span>
        <h1>84 <em>días</em> después</h1>
        <p>Aquí tienes a la mujer que empezó esto — y a la que sale hoy al otro lado. Sube tu foto “después” y colócalas lado a lado.</p>
      </div>

      <div className="reveal-compare">
        <div className="reveal-slot">
          <span className="rs-label">Antes · Día 1</span>
          <span className="rs-date">{state.startDate || '—'}</span>
          {state.photoBefore
            ? <>
                <img src={state.photoBefore} alt="antes" />
                <a className="dl-photo" href={state.photoBefore} download="antes-dia-1.png">↓ Descargar foto de antes</a>
              </>
            : <div className="ba-placeholder"><span style={{ color: 'var(--ink-3)', fontStyle: 'italic', fontFamily: 'Fraunces, serif' }}>sin foto inicial</span></div>
          }
        </div>
        <div className="arrow">→</div>
        <div className="reveal-slot">
          <span className="rs-label">Después · Día 84</span>
          <span className="rs-date">Hoy</span>
          <PhotoSlot value={photoAfter} onChange={setPhotoAfter} label="Foto después" subtitle="Misma luz, misma pose. Toca el placeholder." />
        </div>
      </div>

      <div className="reveal-message">
        <h3>Esto no iba de <em>perder peso</em>.</h3>
        <p>Iba de demostrarte que eres capaz de sostener algo durante 84 días seguidos. Y lo hiciste.</p>
        <p>El cuerpo que tienes hoy lo construiste tú: comida a comida, entreno a entreno, decisión a decisión. Nadie puede quitarte eso.</p>
        <p style={{ fontFamily: 'Fraunces, serif', fontStyle: 'italic', marginTop: 20, fontSize: 18, color: 'var(--rose)' }}>— Ahora el siguiente capítulo es tuyo.</p>
      </div>

      <div className="reveal-stats">
        <div className="reveal-stat"><div className="r-v">{totalEntries}</div><div className="r-k">Días registrados</div></div>
        <div className="reveal-stat"><div className="r-v">{trainedCount}</div><div className="r-k">Entrenos completados</div></div>
        <div className="reveal-stat"><div className="r-v">{avgKcal || '—'}</div><div className="r-k">Kcal media / día</div></div>
        <div className="reveal-stat"><div className="r-v"><em>{weightChange}</em><span style={{ fontSize: 18, color: 'var(--ink-3)' }}> kg</span></div><div className="r-k">Peso (inicio → fin)</div></div>
      </div>

      <div className="restart-block">
        <h3>¿Y ahora qué?</h3>
        <p>Esto fue el principio. Si te apetece volver a empezar con fuerzas renovadas, puedes reiniciar el reto desde cero.</p>
        <button className="restart-btn" onClick={() => setConfirming(true)}>Reiniciar el reto ↺</button>
      </div>

      {confirming && (
        <div className="restart-overlay" onClick={() => setConfirming(false)}>
          <div className="restart-modal" onClick={e => e.stopPropagation()}>
            <h4>¿Seguro que quieres reiniciar?</h4>
            <p>Se borrarán <strong>todos tus datos</strong>: días registrados, peso, comidas, pasos, entrenos, tu diario y tus fotos de antes y después. Tendrás que empezar de nuevo desde el día 1.</p>
            <p className="rm-warn">Esta acción no se puede deshacer.</p>
            <div className="rm-actions">
              <button className="rm-cancel" onClick={() => setConfirming(false)}>No, conservar mi reto</button>
              <button className="rm-confirm" onClick={restartReto}>Sí, borrar y empezar de nuevo</button>
            </div>
          </div>
        </div>
      )}
    </div>
  );
}

// --- Diario — entradas libres que se acumulan ---
function JournalScreen({ state, setState }) {
  const entries = state.journal || [];
  // ordenadas por fecha desc
  const sorted = [...entries].sort((a, b) => (b.date || '').localeCompare(a.date || ''));

  const [draftDate, setDraftDate] = useState(new Date().toISOString().slice(0, 10));
  const [draftText, setDraftText] = useState('');

  const save = () => {
    if (!draftText.trim()) return;
    const id = Date.now();
    setState(s => ({
      ...s,
      journal: [...(s.journal || []), { id, date: draftDate, text: draftText.trim() }]
    }));
    setDraftText('');
    setDraftDate(new Date().toISOString().slice(0, 10));
  };

  const remove = (id) => setState(s => ({ ...s, journal: (s.journal || []).filter(e => e.id !== id) }));

  const fmtDate = (iso) => {
    if (!iso) return '';
    const d = new Date(iso + 'T00:00:00');
    return d.toLocaleDateString('es-ES', { day: '2-digit', month: 'long', year: 'numeric' });
  };

  return (
    <div data-screen-label="Diario">
      {/* Hero editorial */}
      <div className="jo-hero">
        <div className="jo-hero-eyebrow">
          <span className="jo-hero-dot" />
          <span>TU DIARIO — VOLUMEN ÚNICO</span>
        </div>
        <h2 className="jo-hero-title">
          Lo que hoy <em>pesa</em>,<br/>
          mañana <em>será</em> un recuerdo.
        </h2>
        <p className="jo-hero-lead">
          Un espacio solo tuyo. Escribe sin filtros: una frase, una victoria,
          un bajón, una idea. Cada entrada queda guardada con su fecha.
          Dentro de tres meses volverás y verás de dónde vienes.
        </p>
        <div className="jo-hero-meta">
          <div className="jo-meta-item">
            <span className="jo-meta-k">Entradas</span>
            <span className="jo-meta-v">{String(sorted.length).padStart(2,'0')}</span>
          </div>
          <div className="jo-meta-item">
            <span className="jo-meta-k">Periodo</span>
            <span className="jo-meta-v"><em>12 semanas</em></span>
          </div>
          <div className="jo-meta-item">
            <span className="jo-meta-k">Quién lo lee</span>
            <span className="jo-meta-v"><em>Solo tú</em></span>
          </div>
        </div>
      </div>

      {/* Tarjeta de nueva entrada — estilo papel */}
      <div className="jo-compose">
        <div className="jo-compose-side">
          <span className="jo-compose-label">ESCRIBIENDO</span>
          <input
            type="date"
            value={draftDate}
            onChange={e => setDraftDate(e.target.value)}
            className="jo-date-input"
          />
          <div className="jo-compose-tip">
            No tiene que ser poesía.<br/>
            Solo tiene que ser <em>tuyo</em>.
          </div>
        </div>
        <div className="jo-compose-body">
          <h4 className="jo-compose-title">¿Qué quieres recordar de hoy?</h4>
          <textarea
            className="jo-textarea"
            value={draftText}
            onChange={e => setDraftText(e.target.value)}
            placeholder="Hoy me sentí… / Hoy conseguí… / Hoy me costó…"
          />
          <div className="jo-compose-actions">
            <span className="jo-wordcount">{draftText.trim().split(/\s+/).filter(Boolean).length} palabras</span>
            <button
              onClick={save}
              disabled={!draftText.trim()}
              className="jo-save-btn"
            >
              Guardar entrada →
            </button>
          </div>
        </div>
      </div>

      {/* Entradas previas */}
      {sorted.length > 0 && (
        <>
          <div className="jo-section-head">
            <span className="jo-section-rule" />
            <span className="jo-section-label">ENTRADAS ANTERIORES</span>
            <span className="jo-section-rule" />
          </div>
          <div className="jo-entries">
            {sorted.map((e, idx) => (
              <article key={e.id} className="jo-entry">
                <aside className="jo-entry-date">
                  <div className="jo-entry-day">{String(new Date(e.date + 'T00:00:00').getDate()).padStart(2,'0')}</div>
                  <div className="jo-entry-month">{new Date(e.date + 'T00:00:00').toLocaleDateString('es-ES', { month: 'long' })}</div>
                  <div className="jo-entry-year">{new Date(e.date + 'T00:00:00').getFullYear()}</div>
                  <div className="jo-entry-num">nº {String(sorted.length - idx).padStart(3,'0')}</div>
                </aside>
                <div className="jo-entry-body">
                  <p className="jo-entry-text">{e.text}</p>
                  <button onClick={() => remove(e.id)} className="jo-entry-del">Eliminar</button>
                </div>
              </article>
            ))}
          </div>
        </>
      )}
    </div>
  );
}

Object.assign(window, { HomeScreen, DayScreen, HistoryScreen, AIScreen, JournalScreen, LockedScreen, RevealScreen });
