// playground.jsx — interactive AI tools powered by OpenRouter

// ─── OpenRouter API layer ─────────────────────────────────────────────────────
// NOTE: Replace with your own API key from https://openrouter.ai/keys
const API_KEY = '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';

window.ai = {
  complete: async (messages, json = false, retries = 2) => {
    for (let attempt = 0; attempt <= retries; attempt++) {
      try {
        const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
          method: 'POST',
          headers: {
            'Authorization': `Bearer ${API_KEY}`,
            'Content-Type': 'application/json',
            'HTTP-Referer': window.location.href,
            'X-Title': 'Jawwad Automation'
          },
          body: JSON.stringify({
            model: 'openai/gpt-oss-120b:free',
            messages: typeof messages === 'string'
              ? [{ role: 'user', content: messages }]
              : messages,
            ...(json ? { response_format: { type: 'json_object' } } : {}),
            max_tokens: json ? 2000 : 1000
          })
        });

        if (!res.ok) {
          const err = await res.json().catch(() => ({}));
          const errorMsg = err?.error?.message || `API error ${res.status}: ${res.statusText}`;
          console.error('OpenRouter error:', err);
          throw new Error(errorMsg);
        }

        const data = await res.json();
        const text = data.choices?.[0]?.message?.content || '';

        if (!text) {
          if (attempt < retries) {
            console.log(`Empty response, retrying... (${attempt + 1}/${retries})`);
            await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
            continue;
          }
          throw new Error('AI model returned empty response. Please try again.');
        }

        if (json) {
          const m = text.match(/\{[\s\S]*\}/);
          if (!m) throw new Error('No JSON in response');
          let raw = m[0];
          // Pass 1: direct parse
          try { return JSON.parse(raw); } catch {}
          // Pass 2: strip trailing commas before } or ]
          raw = raw.replace(/,(\s*[}\]])/g, '$1');
          try { return JSON.parse(raw); } catch {}
          // Pass 3: strip unescaped control chars inside string values
          raw = raw.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, ' ');
          try { return JSON.parse(raw); } catch {}
          // Pass 4: truncate at last valid closing brace
          const lastBrace = raw.lastIndexOf('}');
          if (lastBrace > 0) {
            try { return JSON.parse(raw.slice(0, lastBrace + 1)); } catch {}
          }
          throw new Error('AI returned malformed JSON. Try again.');
        }

        return text;
      } catch (e) {
        if (attempt === retries) {
          console.error('AI completion error:', e);
          throw e;
        }
        console.log(`Error, retrying... (${attempt + 1}/${retries})`, e.message);
        await new Promise(r => setTimeout(r, 1000 * (attempt + 1)));
      }
    }
  }
};

const Spinner = () => (
  <span style={{
    display: 'inline-block', width: 13, height: 13, borderRadius: '50%',
    border: '2px solid color-mix(in oklab, var(--accent), transparent 60%)',
    borderTopColor: 'var(--accent)', animation: 'pg-spin 0.7s linear infinite'
  }} />
);

// ─── Markdown → clean HTML (for improved resume display) ─────────────────────
const renderMd = (text) => {
  if (!text) return { __html: '' };
  text = text.replace(/[-–—]*\s*(end of resume|end resume)\s*[-–—]*/gi,'').trim();
  let s = text
    .replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;')
    // headers (### or ## or #)
    .replace(/^###\s+(.+)$/gm,'<div class="rs-md-h3">$1</div>')
    .replace(/^##\s+(.+)$/gm,'<div class="rs-md-h2">$1</div>')
    .replace(/^#\s+(.+)$/gm,'<div class="rs-md-h1">$1</div>')
    // ALL-CAPS section headers (bare lines like "PROFESSIONAL SUMMARY")
    .replace(/^([A-Z][A-Z\s&\/\-·]{4,})$/gm,'<div class="rs-md-h3">$1</div>')
    // bold
    .replace(/\*\*(.+?)\*\*/g,'<strong>$1</strong>')
    // italic (avoid single * in bullets)
    .replace(/(?<!\w)\*([^*\n]+?)\*(?!\w)/g,'<em>$1</em>')
    // horizontal rules
    .replace(/^---+$/gm,'<div class="rs-md-sep"></div>')
    // pipe table separator rows → skip
    .replace(/^\|[\s\-:|]+\|[\s\-:|]*$/gm,'')
    // pipe table data rows → key/value row
    .replace(/^\|\s*([^|\n]+?)\s*\|\s*([^|\n]+?)\s*\|.*$/gm,(_,k,v)=>{
      if(/^[-:\s]+$/.test(k)) return '';
      return `<div class="rs-md-kv"><span class="rs-md-k">${k}</span><span class="rs-md-v">${v}</span></div>`;
    })
    // bullet items
    .replace(/^[-•]\s+(.+)$/gm,'<div class="rs-md-li"><span class="rs-md-bull">•</span><span>$1</span></div>')
    // double newline → gap
    .replace(/\n\n+/g,'<div class="rs-md-gap"></div>')
    // single newline → br
    .replace(/\n/g,'<br/>');
  return { __html: s };
};

// Strip markdown for plain-text download
const mdClean = (text) => text
  .replace(/^#{1,3}\s*/gm,'')
  .replace(/\*\*/g,'').replace(/\*/g,'')
  .replace(/^---+$/gm,'')
  .replace(/^\|[\s\-:|]+\|[\s\-:|]*$/gm,'')
  .replace(/^\|(.+)\|$/gm,(_,row)=>row.split('|').map(c=>c.trim()).filter(Boolean).join('  |  '))
  .replace(/[-–—]*\s*(end of resume|end resume)\s*[-–—]*/gi,'')
  .replace(/\n{3,}/g,'\n\n')
  .trim();

// Sanitize to jsPDF WinAnsi (Latin-1 subset) — kills monospace fallback
const pdfSafe = (text) => text
  .replace(/[•·▪▸▶◆◉◈]/g, '-')
  .replace(/[─━═─]/g, '-')
  .replace(/[""]/g, '"').replace(/['']/g, "'")
  .replace(/[–—]/g, '-')
  .replace(/…/g, '...')
  .replace(/[^\x00-\xFF]/g, '');

// ─── Tool 1: Automation ROI Audit ─────────────────────────────────────────────
// Most valuable for Jawwad's visitors: shows them exactly what automation is worth
const ROIAudit = () => {
  const [task, setTask] = React.useState('Manually entering new client details into our CRM after every sales call');
  const [freq, setFreq] = React.useState('10');
  const [mins, setMins] = React.useState('20');
  const [rate, setRate] = React.useState('75');
  const [out, setOut] = React.useState(null);
  const [loading, setLoading] = React.useState(false);
  const [err, setErr] = React.useState('');

  const annualHours = ((+freq * +mins) / 60 * 52).toFixed(0);
  const annualCost = ((+freq * +mins) / 60 * 52 * +rate).toFixed(0);

  const run = async () => {
    if (!task.trim()) return;
    setLoading(true); setOut(null); setErr('');
    try {
      const result = await window.ai.complete([
        {
          role: 'system',
          content: 'You are an automation consultant. Return ONLY valid JSON, no commentary before or after.'
        },
        {
          role: 'user',
          content: `Analyse this manual business task and return a JSON automation report.

Task: "${task}"
Frequency: ${freq} times/week
Time per run: ${mins} minutes
Hourly cost: $${rate}/hr
Annual hours wasted: ${annualHours}h
Annual cost: $${annualCost}

Return this exact JSON shape:
{
  "headline": "One punchy sentence about the cost of this task",
  "pain_level": "low|medium|high|critical",
  "tools": ["tool1", "tool2", "tool3"],
  "approach": "2-sentence plain English description of how to automate this",
  "complexity": "Quick win|Medium build|Complex system",
  "build_days": "X–Y days",
  "payback": "Pays back in X weeks/months",
  "steps": [
    {"label": "Step name", "detail": "What happens"},
    {"label": "Step name", "detail": "What happens"},
    {"label": "Step name", "detail": "What happens"}
  ],
  "verdict": "One strong sentence on whether they should automate this NOW"
}`
        }
      ], true);
      setOut(result);
    } catch (e) {
      setErr(e.message || 'Something went wrong. Try again.');
    }
    setLoading(false);
  };

  const painColor = { low: 'var(--accent)', medium: 'var(--accent)', high: 'var(--danger)', critical: 'var(--danger)' };
  const complexColor = { 'Quick win': 'var(--success)', 'Medium build': 'var(--accent)', 'Complex system': 'var(--ai)' };

  return (
    <div className="pg-card">
      <div className="pg-tag">Automation · ROI</div>
      <h3>Automation ROI Audit</h3>
      <p>Describe a task you do manually. Get the real annual cost and a concrete automation plan.</p>

      <label className="pg-field">
        <span>What do you do manually?</span>
        <textarea rows={2} value={task} onChange={e => setTask(e.target.value)}
          placeholder="e.g. Copy leads from email into spreadsheet every morning" />
      </label>

      <div className="pg-row-3">
        <label className="pg-field">
          <span>Times / week</span>
          <input type="number" min="1" value={freq} onChange={e => setFreq(e.target.value)} />
        </label>
        <label className="pg-field">
          <span>Minutes / run</span>
          <input type="number" min="1" value={mins} onChange={e => setMins(e.target.value)} />
        </label>
        <label className="pg-field">
          <span>Your hourly rate ($)</span>
          <input type="number" min="1" value={rate} onChange={e => setRate(e.target.value)} />
        </label>
      </div>

      <div className="pg-preview-bar">
        <span>≈ <strong>{annualHours}h/yr</strong> wasted</span>
        <span className="pg-dot" />
        <span>≈ <strong>${parseInt(annualCost).toLocaleString()}/yr</strong> cost</span>
      </div>

      <button className="pg-run" onClick={run} disabled={loading || !task.trim()}>
        {loading ? <><Spinner /> Auditing…</> : <>Run ROI audit →</>}
      </button>

      {err && <div className="pg-err">{err}</div>}

      {out && (
        <div className="pg-out pg-roi-out" style={{ fontFamily: 'var(--font-sans)' }}>
          <div className="pg-roi-head">
            <div className="pg-roi-headline">{out.headline}</div>
            <div className="pg-roi-badges">
              <span className="pg-badge" style={{ color: painColor[out.pain_level], borderColor: 'currentColor', background: `color-mix(in oklab, currentColor, transparent 85%)` }}>
                {out.pain_level} pain
              </span>
              <span className="pg-badge" style={{ color: complexColor[out.complexity], borderColor: 'currentColor', background: `color-mix(in oklab, currentColor, transparent 85%)` }}>
                {out.complexity}
              </span>
              <span className="pg-badge" style={{ color: 'var(--success)', borderColor: 'var(--success)', background: 'color-mix(in oklab, var(--success), transparent 85%)' }}>
                {out.payback}
              </span>
            </div>
          </div>

          <div className="pg-roi-approach">{out.approach}</div>

          <div className="pg-roi-steps">
            <div className="pg-k">Automation flow</div>
            {(out.steps || []).map((s, i) => (
              <div key={i} className="pg-roi-step">
                <div className="pg-roi-step-i">{String(i + 1).padStart(2, '0')}</div>
                <div>
                  <div className="pg-roi-step-l">{s.label}</div>
                  <div className="pg-roi-step-d">{s.detail}</div>
                </div>
              </div>
            ))}
          </div>

          <div className="pg-roi-row">
            <div className="pg-roi-col">
              <div className="pg-k">Recommended tools</div>
              <div className="pg-chips-row">
                {(out.tools || []).map((t, i) => <span key={i} className="pg-chip">{t}</span>)}
              </div>
            </div>
            <div className="pg-roi-col">
              <div className="pg-k">Build time</div>
              <div className="pg-roi-build">{out.build_days}</div>
            </div>
          </div>

          <div className="pg-roi-verdict">
            <span className="pg-verdict-icon">→</span> {out.verdict}
          </div>
        </div>
      )}
    </div>
  );
};

// ─── Score ring SVG ───────────────────────────────────────────────────────────
const ScoreRing = ({ score, color }) => {
  const r = 38, cx = 48, cy = 48, circ = 2 * Math.PI * r;
  const dash = (score / 100) * circ;
  return (
    <svg width="96" height="96" viewBox="0 0 96 96" style={{ flexShrink: 0 }}>
      <circle cx={cx} cy={cy} r={r} fill="none"
        stroke="var(--border-strong)" strokeWidth="6" />
      <circle cx={cx} cy={cy} r={r} fill="none"
        stroke={color} strokeWidth="6"
        strokeDasharray={`${dash} ${circ}`} strokeLinecap="round"
        transform={`rotate(-90 ${cx} ${cy})`}
        style={{ transition: 'stroke-dasharray 1s cubic-bezier(.22,.8,.32,1) 0.1s' }} />
      <text x={cx} y={cy - 4} textAnchor="middle" fill={color}
        fontSize="22" fontWeight="700" fontFamily="var(--font-display)">{score}</text>
      <text x={cx} y={cy + 14} textAnchor="middle" fill="var(--muted)"
        fontSize="10" fontFamily="var(--font-mono)">/100</text>
    </svg>
  );
};

// ─── Tool 2: Resume Scorer ────────────────────────────────────────────────────
const ResumeDemo = () => {
  const [role, setRole] = React.useState('Senior Backend Engineer (Python, AWS)');
  const [resume, setResume] = React.useState('');
  const [inputMode, setInputMode] = React.useState('upload');
  const [fileName, setFileName] = React.useState('');
  const [pdfPages, setPdfPages] = React.useState([]);
  const [extracting, setExtracting] = React.useState(false);
  const [dragOver, setDragOver] = React.useState(false);
  const [out, setOut] = React.useState(null);
  const [loading, setLoading] = React.useState(false);
  const [err, setErr] = React.useState('');
  const [improving, setImproving] = React.useState(false);
  const [improvedText, setImprovedText] = React.useState('');
  const fileRef = React.useRef(null);

  // PDF → canvas pages + extracted text
  const processPdf = async (file) => {
    setExtracting(true); setErr(''); setPdfPages([]); setResume(''); setFileName(file.name);
    try {
      const buf = await file.arrayBuffer();
      const pdf = await pdfjsLib.getDocument({ data: buf }).promise;
      const pages = [];
      const limit = Math.min(pdf.numPages, 3);
      for (let i = 1; i <= limit; i++) {
        const page = await pdf.getPage(i);
        const vp = page.getViewport({ scale: 1.6 });
        const canvas = document.createElement('canvas');
        canvas.width = vp.width; canvas.height = vp.height;
        await page.render({ canvasContext: canvas.getContext('2d'), viewport: vp }).promise;
        pages.push(canvas.toDataURL('image/jpeg', 0.88));
      }
      setPdfPages(pages);
      let text = '';
      for (let i = 1; i <= pdf.numPages; i++) {
        const page = await pdf.getPage(i);
        const tc = await page.getTextContent();
        text += tc.items.map(it => it.str).join(' ') + '\n';
      }
      setResume(text.trim());
    } catch (e) { setErr('Could not parse PDF. Switch to "Paste text" tab instead.'); }
    setExtracting(false);
  };

  const handleFile = (file) => {
    if (!file) return;
    if (file.name.endsWith('.pdf')) { processPdf(file); }
    else if (file.name.endsWith('.txt')) {
      const r = new FileReader();
      r.onload = e => { setResume(e.target.result); setFileName(file.name); setPdfPages([]); };
      r.readAsText(file);
    } else { setErr('Upload a .pdf or .txt file.'); }
  };

  const onDrop = (e) => {
    e.preventDefault(); setDragOver(false); handleFile(e.dataTransfer.files[0]);
  };

  const run = async () => {
    setLoading(true); setOut(null); setErr('');
    try {
      const result = await window.ai.complete([
        { role: 'system', content: 'Expert hiring manager and resume coach. Return ONLY valid JSON, no commentary.' },
        { role: 'user', content: `Score this resume. Return exactly:
{"score":<0-100>,"verdict":"strong fit|possible fit|weak fit","strengths":["...","...","..."],"gaps":["...","...","..."],"ats_tips":["...","..."],"recommend":"One clear next step"}

Role: ${role}
Resume: ${resume.slice(0, 3200).replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, ' ')}` }
      ], true);
      setOut(result);
    } catch (e) { setErr(e.message || 'Could not score. Try again.'); }
    setLoading(false);
  };

  const improveResume = async () => {
    setImproving(true); setImprovedText(''); setErr('');
    try {
      const text = await window.ai.complete([
        { role: 'system', content: 'You are a brutal, no-nonsense resume editor. Your job is to strip all fluff and rewrite every line to show concrete impact. You never use buzzwords. You never use vague claims. Every bullet must answer: what did you do, how, and what was the result (with a number where possible). Return ONLY the improved resume text, no commentary.' },
        { role: 'user', content: `Rewrite this resume for the role: ${role}

Current resume:
${resume.slice(0, 3200).replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, ' ')}

RULES:
- NEVER use these buzzwords: results-driven, detail-oriented, passionate, dynamic, synergy, leverage, innovative, proactive, team player, self-starter, go-getter, guru, ninja, rockstar, thought leader, strategic, visionary, seasoned, proven track record, fast-paced, hard-working, motivated, driven, dedicated, responsible for, assisted with, helped with, worked on
- Every experience bullet must follow: [Action verb] + [what you built/did] + [specific outcome or number]
  Good: "Cut API response time 40% by replacing N+1 queries with batch fetching"
  Bad: "Optimized backend performance to improve user experience"
- Summary: 2 sentences max. State title, years of experience, and one concrete differentiator. No adjectives.
- Skills: list tools only, no phrases
- Remove any bullet that has no concrete outcome and cannot be given one
- Add role-specific keywords for ATS naturally, not as a keyword dump

FORMATTING: ALL-CAPS section headers (PROFESSIONAL SUMMARY, EXPERIENCE, SKILLS, EDUCATION). Use "- " for bullets. Plain text, no markdown. Return full resume only.` }
      ]);
      setImprovedText(text);
    } catch(e) { setErr(e.message || 'Could not improve resume. Try again.'); }
    setImproving(false);
  };

  const downloadTxt = () => {
    const blob = new Blob([mdClean(improvedText)], { type: 'text/plain; charset=utf-8' });
    const url = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = url; a.download = 'improved_resume.txt';
    document.body.appendChild(a); a.click();
    document.body.removeChild(a); URL.revokeObjectURL(url);
  };

  const downloadPdf = () => {
    const { jsPDF } = window.jspdf;
    const doc = new jsPDF({ unit:'mm', format:'a4' });
    const margin = 18;
    const maxW = doc.internal.pageSize.getWidth() - margin * 2;
    const pageH = doc.internal.pageSize.getHeight();

    // Strip markdown, then strip every non-Latin-1 char so helvetica never falls back to monospace
    const clean = pdfSafe(mdClean(improvedText));

    // Section header: 5+ chars, nothing but A-Z 0-9 spaces & / -
    const isHeader = (s) => s.length >= 5 && /^[A-Z][A-Z0-9 &\\/\-]{4,}$/.test(s);

    let y = margin;
    for (const rawLine of clean.split('\n')) {
      const line = rawLine.trimEnd();
      if (!line.trim()) { y += 2.5; continue; }

      const hdr = isHeader(line.trim());
      doc.setFont('helvetica', hdr ? 'bold' : 'normal');
      doc.setFontSize(hdr ? 11 : 10);

      const wrapped = doc.splitTextToSize(line.trimStart(), maxW);
      for (const wl of wrapped) {
        if (y > pageH - margin) { doc.addPage(); y = margin; }
        doc.text(wl, margin, y);
        y += 5.5;
      }
      if (hdr) y += 1.5; // breathing room after headers
    }
    doc.save('improved_resume.pdf');
  };

  const colorFor = s => s >= 75 ? 'var(--success)' : s >= 50 ? 'var(--accent)' : 'var(--danger)';
  const hasContent = resume.trim().length > 40;

  // Preview panel — shared between both columns
  const PreviewPanel = () => (
    <div className="rs-preview-panel">
      {extracting ? (
        <div className="rs-skeleton">
          {[1,0.9,0.6,1,0.75,0.5,0.9,0.7,1,0.6].map((w,i)=>(
            <div key={i} className="rs-skel-line" style={{width:`${w*100}%`}} />
          ))}
        </div>
      ) : pdfPages.length > 0 ? (
        <div className="rs-pdf-pages">
          {pdfPages.map((src,i)=>(
            <img key={i} src={src} alt={`Page ${i+1}`} className="rs-pdf-page" />
          ))}
        </div>
      ) : inputMode === 'paste' && resume.trim() ? (
        <div className="rs-text-preview">
          <div className="rs-preview-label">Preview</div>
          <div className="rs-text-body">{resume}</div>
        </div>
      ) : (
        <div className="rs-preview-empty">
          <div className="rs-empty-icon">▤</div>
          <div className="rs-empty-t">Resume preview</div>
          <div className="rs-empty-sub">PDF renders here · no browser toolbar</div>
        </div>
      )}
    </div>
  );

  return (
    <div className="rs-outer">

      {/* ── Left: card with controls + results ── */}
      <div className="pg-card rs-card">
        <div className="pg-tag" style={{ color:'var(--ai)', borderColor:'color-mix(in oklab,var(--ai),transparent 70%)', background:'color-mix(in oklab,var(--ai),transparent 86%)' }}>AI · Hiring</div>
        <h3>Resume scorer</h3>
        <p>Upload or paste a resume. Get a structured fit score, gaps, and ATS tips in seconds.</p>

        <label className="pg-field">
          <span>Target role</span>
          <input value={role} onChange={e => setRole(e.target.value)}
            placeholder="e.g. Product Manager, SaaS startup" />
        </label>

        <div className="rs-mode-tabs">
          <button className={`rs-mode-btn ${inputMode==='upload'?'on':''}`} onClick={()=>setInputMode('upload')}>Upload file</button>
          <button className={`rs-mode-btn ${inputMode==='paste'?'on':''}`} onClick={()=>setInputMode('paste')}>Paste text</button>
        </div>

        {inputMode === 'upload' ? (
          <div
            className={`rs-drop-zone ${dragOver?'drag-over':''} ${extracting?'extracting':''} ${fileName&&!extracting?'has-file':''}`}
            onDragOver={e=>{e.preventDefault();setDragOver(true);}}
            onDragLeave={()=>setDragOver(false)}
            onDrop={onDrop}
            onClick={()=>!extracting&&fileRef.current?.click()}
          >
            <input ref={fileRef} type="file" accept=".pdf,.txt"
              style={{display:'none'}} onChange={e=>handleFile(e.target.files[0])} />
            {extracting ? (<>
              <div className="rs-drop-icon rs-spin">⊙</div>
              <div className="rs-drop-title">Extracting…</div>
            </>) : fileName ? (<>
              <div className="rs-drop-icon rs-done">✓</div>
              <div className="rs-drop-title">{fileName}</div>
              <div className="rs-drop-hint">Click to replace</div>
            </>) : (<>
              <div className="rs-drop-icon">⊞</div>
              <div className="rs-drop-title">Drop PDF here</div>
              <div className="rs-drop-hint">or click to browse · .pdf or .txt</div>
            </>)}
          </div>
        ) : (
          <label className="pg-field">
            <span>Resume text</span>
            <textarea rows={8} value={resume} onChange={e=>setResume(e.target.value)}
              placeholder="Paste your resume content here…" />
          </label>
        )}

        <button className="pg-run rs-score-btn" onClick={run}
          disabled={loading || !hasContent || !role.trim()}>
          {loading ? <><Spinner /> Scoring…</> : <>Score this resume →</>}
        </button>
        {err && <div className="pg-err">{err}</div>}

        {/* Results inside card, below controls */}
        {out && (
          <div className="pg-out rs-results">
            <div className="rs-score-header">
              <ScoreRing score={out.score} color={colorFor(out.score)} />
              <div className="rs-score-meta">
                <div className="rs-verdict" style={{color:colorFor(out.score)}}>{out.verdict}</div>
                <div className="rs-recommend">{out.recommend}</div>
              </div>
            </div>
            <div className="rs-cols">
              <div className="rs-col">
                <div className="pg-k">Strengths</div>
                {(out.strengths||[]).map((s,i)=>(
                  <div key={i} className="rs-item rs-good"><span className="rs-dot">+</span>{s}</div>
                ))}
              </div>
              <div className="rs-col">
                <div className="pg-k">Gaps</div>
                {(out.gaps||[]).map((s,i)=>(
                  <div key={i} className="rs-item rs-bad"><span className="rs-dot">−</span>{s}</div>
                ))}
              </div>
              <div className="rs-col">
                <div className="pg-k">ATS tips</div>
                {(out.ats_tips||[]).map((s,i)=>(
                  <div key={i} className="rs-item rs-tip"><span className="rs-dot">◈</span>{s}</div>
                ))}
              </div>
            </div>

            {/* Improve CTA — always available after scoring */}
            {!improvedText && (
              <div className="rs-improve-bar" style={out.score >= 75 ? {background:'color-mix(in oklab,var(--accent),transparent 93%)',borderColor:'color-mix(in oklab,var(--accent),transparent 70%)'} : undefined}>
                <div className="rs-improve-msg">
                  {out.score >= 75
                    ? <>Good score — AI can sharpen it further for <em>{role}</em></>
                    : <>Score is low — AI can rewrite this resume for <em>{role}</em></>}
                </div>
                <button className="pg-run" onClick={improveResume} disabled={improving || !resume.trim()}
                  style={{alignSelf:'center', flexShrink:0}}>
                  {improving ? <><Spinner /> Rewriting…</> : out.score >= 75 ? <>Polish with AI →</> : <>Improve with AI →</>}
                </button>
              </div>
            )}
          </div>
        )}

        {/* Improved resume + downloads */}
        {improvedText && (
          <div className="rs-improved">
            <div className="rs-improved-hd">
              <span className="pg-k" style={{alignSelf:'center'}}>Improved resume</span>
              <div className="rs-dl-btns">
                <button className="pg-copy" onClick={downloadTxt}>↓ Download .txt</button>
                <button className="pg-copy" onClick={downloadPdf}>↓ Download PDF</button>
              </div>
            </div>
            <div className="rs-improved-body rs-improved-html" dangerouslySetInnerHTML={renderMd(improvedText)} />
          </div>
        )}
      </div>

      {/* ── Right: standalone preview column ── */}
      <div className="rs-preview-col">
        <div className="rs-preview-col-header">
          <span className="rs-preview-col-label">Resume preview</span>
          {fileName && <span className="rs-preview-col-fname">{fileName}</span>}
          {!fileName && <span className="rs-preview-col-hint">Upload to see preview</span>}
        </div>
        <PreviewPanel />
      </div>

    </div>
  );
};

// ─── Tool 3: Cold Email / Business Email Writer ───────────────────────────────
const EmailWriter = () => {
  const types = ['Cold outreach', 'Follow-up (no reply)', 'Proposal request', 'Re-engagement', 'Partnership pitch'];
  const [type, setType] = React.useState('Cold outreach');
  const [sender, setSender] = React.useState('I build automation systems that save businesses 10+ hours/week');
  const [target, setTarget] = React.useState('Marketing agency owner who handles client reporting manually');
  const [toEmail, setToEmail] = React.useState('');
  const [loading, setLoading] = React.useState(false);
  const [err, setErr] = React.useState('');
  // review step state
  const [reviewing, setReviewing] = React.useState(false);
  const [editSubject, setEditSubject] = React.useState('');
  const [editBody, setEditBody] = React.useState('');
  const [editPs, setEditPs] = React.useState('');
  const [why, setWhy] = React.useState('');
  const [copied, setCopied] = React.useState(false);
  const [sent, setSent] = React.useState(false);

  const generate = async () => {
    setLoading(true); setErr(''); setReviewing(false); setCopied(false); setSent(false);
    try {
      const result = await window.ai.complete([
        { role: 'system', content: 'Elite B2B copywriter. Short, specific, human emails. Return ONLY valid JSON.' },
        { role: 'user', content: `Write a ${type} email. Return exactly:
{"subject":"...","body":"...","ps":"...","why_it_works":"One sentence on what makes this email effective"}

Sender: ${sender}
Recipient: ${target}
Type: ${type}

Rules: Max 5 sentences body. Reference recipient specifically. One soft CTA. No filler openers. PS optional but powerful.` }
      ], true);
      setEditSubject(result.subject || '');
      setEditBody(result.body || '');
      setEditPs(result.ps || '');
      setWhy(result.why_it_works || '');
      setReviewing(true);
    } catch (e) { setErr(e.message || 'Could not generate. Try again.'); }
    setLoading(false);
  };

  const fullText = () =>
    `Subject: ${editSubject}\n\n${editBody}${editPs ? `\n\nPS: ${editPs}` : ''}`;

  const copyEmail = () => {
    navigator.clipboard.writeText(fullText()).then(() => {
      setCopied(true); setTimeout(() => setCopied(false), 2500);
    });
  };

  const sendEmail = () => {
    if (!toEmail.trim()) { setErr('Enter recipient email to send.'); return; }
    const to = encodeURIComponent(toEmail.trim());
    const sub = encodeURIComponent(editSubject);
    const body = encodeURIComponent(`${editBody}${editPs ? `\n\nPS: ${editPs}` : ''}`);
    // Opens Gmail compose in browser — pre-filled, one click to send
    window.open(`https://mail.google.com/mail/?view=cm&to=${to}&su=${sub}&body=${body}`, '_blank');
    setSent(true); setTimeout(() => setSent(false), 3000);
  };

  const reset = () => { setReviewing(false); setErr(''); };

  return (
    <div className="pg-card">
      <div className="pg-tag" style={{ color:'var(--success)', borderColor:'color-mix(in oklab,var(--success),transparent 70%)', background:'color-mix(in oklab,var(--success),transparent 86%)' }}>Sales · Outreach</div>
      <h3>Business email writer</h3>
      <p>Describe who you are and who you're emailing. Edit the draft, then send directly.</p>

      {!reviewing ? (
        <>
          <div className="pg-field">
            <span>Email type</span>
            <CustomSelect value={type} onChange={setType} options={types} />
          </div>
          <label className="pg-field">
            <span>Recipient email (optional)</span>
            <input type="email" value={toEmail} onChange={e => setToEmail(e.target.value)}
              placeholder="prospect@company.com" />
          </label>
          <label className="pg-field">
            <span>What you do / offer</span>
            <input value={sender} onChange={e => setSender(e.target.value)}
              placeholder="e.g. I build no-code automation for e-commerce brands" />
          </label>
          <label className="pg-field">
            <span>Who you're emailing</span>
            <input value={target} onChange={e => setTarget(e.target.value)}
              placeholder="e.g. Agency owner handling client reports manually" />
          </label>
          <button className="pg-run" onClick={generate} disabled={loading || !sender.trim() || !target.trim()}>
            {loading ? <><Spinner /> Writing…</> : <>Generate email →</>}
          </button>
          {err && <div className="pg-err">{err}</div>}
        </>
      ) : (
        <div className="pg-email-review">
          <div className="pg-email-review-hd">
            <span className="pg-k" style={{alignSelf:'center'}}>Review &amp; edit before sending</span>
            <button className="pg-copy" onClick={reset} style={{marginLeft:'auto'}}>← Regenerate</button>
          </div>

          <label className="pg-field">
            <span>To</span>
            <input type="email" value={toEmail} onChange={e => setToEmail(e.target.value)}
              placeholder="prospect@company.com" />
          </label>
          <label className="pg-field">
            <span>Subject</span>
            <input value={editSubject} onChange={e => setEditSubject(e.target.value)} />
          </label>
          <label className="pg-field">
            <span>Body</span>
            <textarea rows={7} value={editBody} onChange={e => setEditBody(e.target.value)} />
          </label>
          <label className="pg-field">
            <span>PS (optional)</span>
            <input value={editPs} onChange={e => setEditPs(e.target.value)}
              placeholder="Leave blank to omit" />
          </label>

          {why && <div className="pg-email-why" style={{fontSize:12.5, color:'var(--accent)', marginTop:2}}>◈ {why}</div>}

          <div className="pg-email-actions">
            <button className="pg-run" onClick={sendEmail}
              style={{background: sent ? 'var(--success)' : undefined}}>
              {sent ? '✓ Opened in Gmail' : `Open in Gmail →${toEmail ? ' '+toEmail : ''}`}
            </button>
            <button className="pg-copy" onClick={copyEmail}>
              {copied ? '✓ Copied!' : 'Copy text'}
            </button>
          </div>
        </div>
      )}
    </div>
  );
};

// ─── Tool 4: Website Scanner ─────────────────────────────────────────────────
const SiteScanner = () => {
  const [url, setUrl] = React.useState('');
  const [loading, setLoading] = React.useState(false);
  const [fetching, setFetching] = React.useState(false);
  const [out, setOut] = React.useState(null);
  const [err, setErr] = React.useState('');

  const run = async () => {
    if (!url.trim()) return;
    setLoading(true); setOut(null); setErr('');
    let pageText = '';
    try {
      setFetching(true);
      const clean = url.trim().replace(/^https?:\/\//, '');
      const resp = await fetch(`https://r.jina.ai/${clean}`, { headers: { 'Accept': 'text/plain' } });
      pageText = await resp.text();
      setFetching(false);
    } catch { setFetching(false); }

    try {
      const result = await window.ai.complete([
        { role: 'system', content: 'Business automation consultant. Return ONLY valid JSON.' },
        { role: 'user', content: `Analyze this website for automation opportunities.
URL: ${url}
${pageText ? 'Page content:\n' + pageText.slice(0, 3500) : 'No page content — infer from URL and domain.'}

Return exactly:
{"business_name":"...","what_they_do":"2-sentence description","industry":"...","automation_score":<0-100>,"pain_points":["...","...","..."],"opportunities":["...","...","..."],"quick_wins":["...","..."],"outreach_angle":"One sentence: how to pitch automation to this business"}` }
      ], true);
      setOut(result);
    } catch(e) { setErr(e.message || 'Could not scan site. Try again.'); }
    setLoading(false);
  };

  return (
    <div className="pg-card">
      <div className="pg-tag" style={{color:'var(--ai)', borderColor:'color-mix(in oklab,var(--ai),transparent 70%)', background:'color-mix(in oklab,var(--ai),transparent 86%)'}}>Research · Intel</div>
      <h3>Website automation scanner</h3>
      <p>Enter any business URL. Get their automation opportunities, pain points, and a personalized outreach angle.</p>
      <label className="pg-field">
        <span>Business website URL</span>
        <input value={url} onChange={e=>setUrl(e.target.value)}
          placeholder="https://someagency.com" type="url" />
      </label>
      <button className="pg-run" onClick={run} disabled={loading || !url.trim()}>
        {loading ? <><Spinner /> {fetching ? 'Reading site…' : 'Analyzing…'}</> : <>Scan website →</>}
      </button>
      {err && <div className="pg-err">{err}</div>}
      {out && (
        <div className="pg-out sc-out">
          <div className="sc-head">
            <div className="sc-meta">
              <div className="sc-biz">{out.business_name}</div>
              <div className="sc-industry">{out.industry}</div>
              <div className="sc-what">{out.what_they_do}</div>
            </div>
            <div className="sc-ring-wrap">
              <ScoreRing score={out.automation_score} color={out.automation_score>=60?'var(--success)':'var(--accent)'} />
              <div className="sc-ring-label">automation<br/>potential</div>
            </div>
          </div>
          <div className="pg-roi-approach" style={{borderLeftColor:'var(--ai)'}}>◈ {out.outreach_angle}</div>
          <div className="pg-grid">
            <div>
              <div className="pg-k">Automation opportunities</div>
              {(out.opportunities||[]).map((o,i)=>(
                <div key={i} className="rs-item rs-tip"><span className="rs-dot">◈</span>{o}</div>
              ))}
              <div className="pg-k" style={{marginTop:12}}>Quick wins</div>
              {(out.quick_wins||[]).map((q,i)=>(
                <div key={i} className="rs-item rs-good"><span className="rs-dot">+</span>{q}</div>
              ))}
            </div>
            <div>
              <div className="pg-k">Pain points detected</div>
              {(out.pain_points||[]).map((p,i)=>(
                <div key={i} className="rs-item rs-bad"><span className="rs-dot">−</span>{p}</div>
              ))}
            </div>
          </div>
        </div>
      )}
    </div>
  );
};

// ─── Tool 5: Workflow Blueprint ───────────────────────────────────────────────
const WorkflowBlueprint = () => {
  const [process, setProcess] = React.useState('');
  const [team, setTeam] = React.useState('5');
  const [loading, setLoading] = React.useState(false);
  const [out, setOut] = React.useState(null);
  const [err, setErr] = React.useState('');
  const complexColor = { 'Quick win':'var(--success)', 'Medium build':'var(--accent)', 'Complex system':'var(--ai)' };

  const run = async () => {
    setLoading(true); setOut(null); setErr('');
    try {
      const result = await window.ai.complete([
        { role: 'system', content: 'Expert automation architect. Return ONLY valid JSON.' },
        { role: 'user', content: `Design an automation blueprint for this process.
Process: ${process}
Team size: ${team} people

Return exactly:
{"summary":"2-3 sentence plain-English overview of what this automation does and why it saves time","title":"Short automation name","trigger":"What starts it","outcome":"End result","time_saved":"X hrs/week","roi_estimate":"Pays back in X weeks","tools":["tool1","tool2","tool3"],"steps":[{"step":"Name","what":"What happens","tool":"Tool used"},{"step":"...","what":"...","tool":"..."},{"step":"...","what":"...","tool":"..."},{"step":"...","what":"...","tool":"..."}],"complexity":"Quick win|Medium build|Complex system","first_action":"Single most important first step today"}` }
      ], true);
      setOut(result);
    } catch(e) { setErr(e.message || 'Could not generate blueprint.'); }
    setLoading(false);
  };

  return (
    <div className="pg-card">
      <div className="pg-tag">Automation · Blueprint</div>
      <h3>Workflow automation blueprint</h3>
      <p>Describe any manual business process. Get a step-by-step automation design with tools, timeline, and first steps.</p>
      <label className="pg-field">
        <span>Describe the manual process</span>
        <textarea rows={3} value={process} onChange={e=>setProcess(e.target.value)}
          placeholder="e.g. Every Monday I pull reports from 3 platforms, merge in Excel, email a summary to 5 managers…" />
      </label>
      <label className="pg-field">
        <span>Team size</span>
        <input type="number" min="1" value={team} onChange={e=>setTeam(e.target.value)} style={{maxWidth:100}} />
      </label>
      <button className="pg-run" onClick={run} disabled={loading || !process.trim()}>
        {loading ? <><Spinner /> Designing…</> : <>Generate blueprint →</>}
      </button>
      {err && <div className="pg-err">{err}</div>}
      {out && (
        <div className="pg-out bp-out">
          {out.summary && <div className="bp-summary">{out.summary}</div>}
          <div className="pg-roi-head">
            <div className="pg-roi-headline">{out.title}</div>
            <div className="pg-roi-badges">
              <span className="pg-badge" style={{color:complexColor[out.complexity]||'var(--accent)',borderColor:'currentColor',background:'color-mix(in oklab,currentColor,transparent 85%)'}}>
                {out.complexity}
              </span>
              <span className="pg-badge" style={{color:'var(--success)',borderColor:'var(--success)',background:'color-mix(in oklab,var(--success),transparent 85%)'}}>
                {out.time_saved} saved
              </span>
              <span className="pg-badge" style={{color:'var(--accent)',borderColor:'var(--accent)',background:'color-mix(in oklab,var(--accent),transparent 85%)'}}>
                {out.roi_estimate}
              </span>
            </div>
            <div className="bp-trigger-row">
              <span className="bp-t-label">Trigger</span>
              <span className="bp-t-v">{out.trigger}</span>
              <span className="bp-arrow">→</span>
              <span className="bp-t-label">Outcome</span>
              <span className="bp-t-v">{out.outcome}</span>
            </div>
          </div>
          <div className="pg-roi-steps">
            <div className="pg-k">Automation steps</div>
            {(out.steps||[]).map((s,i)=>(
              <div key={i} className="pg-roi-step">
                <div className="pg-roi-step-i">{String(i+1).padStart(2,'0')}</div>
                <div style={{flex:1}}>
                  <div className="pg-roi-step-l">{s.step}</div>
                  <div className="pg-roi-step-d">{s.what}</div>
                </div>
                <span className="bp-step-tool">{s.tool}</span>
              </div>
            ))}
          </div>
          <div className="pg-roi-row">
            <div className="pg-roi-col">
              <div className="pg-k">Tools needed</div>
              <div className="pg-chips-row">
                {(out.tools||[]).map((t,i)=><span key={i} className="pg-chip">{t}</span>)}
              </div>
            </div>
          </div>
          <div className="pg-roi-verdict">
            <span className="pg-verdict-icon">→</span> <strong>Start here:</strong> {out.first_action}
          </div>
        </div>
      )}
    </div>
  );
};

// ─── Tool 6: Pitch Angle Maker ────────────────────────────────────────────────
const PitchMaker = () => {
  const [company, setCompany] = React.useState('');
  const [problem, setProblem] = React.useState('');
  const [loading, setLoading] = React.useState(false);
  const [out, setOut] = React.useState(null);
  const [revealed, setRevealed] = React.useState([]); // which card indices are revealed
  const [err, setErr] = React.useState('');

  const run = async () => {
    setLoading(true); setOut(null); setRevealed([]); setErr('');
    try {
      const result = await window.ai.complete([
        { role: 'system', content: 'Elite sales strategist specializing in automation consulting. Return ONLY valid JSON.' },
        { role: 'user', content: `Create personalized outreach angles for pitching automation to this prospect.
Company/Prospect: ${company}
Known problem/context: ${problem}

Return exactly:
{"primary_pain":"Core pain in one sharp sentence","angles":[{"hook":"Opening line that grabs attention","value":"Specific value this angle leads with","subject":"Email subject line"},{"hook":"...","value":"...","subject":"..."},{"hook":"...","value":"...","subject":"..."}],"best_angle":0,"avoid":"One thing NOT to say","follow_up":"Best follow-up timing"}` }
      ], true);
      setOut(result);
      // Stagger card reveals — first immediately, others 500ms apart
      setTimeout(() => setRevealed([0]),       80);
      setTimeout(() => setRevealed([0,1]),     580);
      setTimeout(() => setRevealed([0,1,2]),  1080);
    } catch(e) { setErr(e.message || 'Could not generate pitch.'); }
    setLoading(false);
  };

  // Skeleton card shown while loading or waiting for reveal
  const SkeletonCard = ({ delay = 0 }) => (
    <div className="pm-card pm-card-skeleton">
      <div className="pm-skel-line" style={{width:'45%'}} />
      <div className="pm-skel-line" style={{width:'85%', marginTop:10}} />
      <div className="pm-skel-line" style={{width:'70%'}} />
      <div className="pm-skel-line" style={{width:'90%'}} />
      <div className="pm-sparkle-row">
        {[0,1,2].map(j => (
          <span key={j} className="pm-sparkle-dot"
            style={{animationDelay:`${delay + j*220}ms`}} />
        ))}
      </div>
    </div>
  );

  return (
    <div className="pg-card">
      <div className="pg-tag" style={{color:'var(--success)', borderColor:'color-mix(in oklab,var(--success),transparent 70%)', background:'color-mix(in oklab,var(--success),transparent 86%)'}}>Sales · Strategy</div>
      <h3>Pitch angle generator</h3>
      <p>Describe a prospect. Get 3 personalized outreach angles, hooks, and subject lines — revealed one by one.</p>
      <label className="pg-field">
        <span>Company / prospect</span>
        <input value={company} onChange={e=>setCompany(e.target.value)}
          placeholder="e.g. Mid-size recruitment agency, 40 staff, uses spreadsheets" />
      </label>
      <label className="pg-field">
        <span>Known problem or context</span>
        <textarea rows={2} value={problem} onChange={e=>setProblem(e.target.value)}
          placeholder="e.g. Recruiters manually track 200+ candidates across emails and spreadsheets" />
      </label>
      <button className="pg-run" onClick={run} disabled={loading || !company.trim() || !problem.trim()}>
        {loading ? <><Spinner /> Generating…</> : <>Generate pitch angles →</>}
      </button>
      {err && <div className="pg-err">{err}</div>}

      {/* 3-card grid — skeleton while loading, fills in on reveal */}
      {(loading || out) && (
        <div className="pm-cards-grid">
          {[0,1,2].map(i => {
            const isRevealed = revealed.includes(i);
            const angle = out?.angles?.[i];
            const isBest = out && i === (out.best_angle ?? 0);

            if (!out || !isRevealed) {
              return <SkeletonCard key={i} delay={i * 120} />;
            }
            return (
              <div key={i} className={`pm-card pm-card-in${isBest?' pm-best':''}`}>
                {isBest && <div className="pm-best-badge">★ Best angle</div>}
                <div className="pm-card-num">0{i+1}</div>
                <div className="pm-subj-label">Subject</div>
                <div className="pm-subj-v">{angle.subject}</div>
                <div className="pm-hook">"{angle.hook}"</div>
                <div className="pm-value">◈ {angle.value}</div>
              </div>
            );
          })}
        </div>
      )}

      {/* Footer — shown only after all 3 revealed */}
      {out && revealed.length === 3 && (
        <div className="pm-footer pm-footer-in">
          <div className="pg-roi-approach" style={{borderLeftColor:'var(--danger)', margin:0}}>
            <strong>Core pain:</strong> {out.primary_pain}
          </div>
          <div className="pm-avoid-timing">
            <span className="pm-avoid"><strong>Avoid:</strong> {out.avoid}</span>
            <span className="pm-timing">◷ Follow up: {out.follow_up}</span>
          </div>
        </div>
      )}
    </div>
  );
};

// ─── Playground section ───────────────────────────────────────────────────────
const Playground = () => {
  const demos = [
    { id: 'roi',      label: '⊞ ROI Audit',      Component: ROIAudit },
    { id: 'resume',   label: '◈ Resume',          Component: ResumeDemo },
    { id: 'email',    label: '✦ Email Writer',    Component: EmailWriter },
    { id: 'site',     label: '◉ Site Scanner',    Component: SiteScanner },
    { id: 'workflow', label: '▤ Workflow',         Component: WorkflowBlueprint },
    { id: 'pitch',    label: '◷ Pitch Maker',     Component: PitchMaker },
  ];
  const [active, setActive] = React.useState('roi');
  const Active = demos.find(d => d.id === active).Component;

  return (
    <section className="section playground" id="playground">
      <Reveal><SectionLabel num="04½" label="Try it live" /></Reveal>
      <Reveal delay={80}><h2 className="sec-h">Six AI tools you can <em>use right now.</em></h2></Reveal>
      <Reveal delay={140}>
        <p className="sec-sub">
          Real AI, real output — powered by GPT-4o. No signup. No fluff.
          Each tool takes under 30 seconds.
        </p>
      </Reveal>

      <Reveal delay={180}>
        <div className="pg-tabs">
          {demos.map(d => (
            <button key={d.id} className={`pg-tab ${d.id === active ? 'on' : ''}`}
              onClick={() => setActive(d.id)}>
              {d.label}
            </button>
          ))}
        </div>
      </Reveal>

      <Reveal delay={220} y={28}>
        <div className="pg-stage" key={active}>
          <Active />
        </div>
      </Reveal>
    </section>
  );
};

window.Playground = Playground;
