/* Agent API view — gives a Claude agent (or any LLM) a clean interface
   to read the current simulation, run scenarios, and get explanations.

   Exposes window.GFAMatrix programmatic API:
     GFAMatrix.simulate(query)         → result JSON
     GFAMatrix.simulateText(spec)      → human-readable summary
     GFAMatrix.recommend(query)        → 3 alternative queries
     GFAMatrix.compare(qA, qB)         → side-by-side delta
     GFAMatrix.taxonomy()              → 560-leaf tree
     GFAMatrix.archetypes(query)       → persona match scores
     GFAMatrix.export()                → full result + AI-readable narrative
*/

const { useState: useAGState, useMemo: useAGMemo, useEffect: useAGEffect } = React;

function AgentAPIView({ query, target, exposure }) {
  const [out, setOut] = useAGState('');
  const [busy, setBusy] = useAGState(false);
  const [aiSummary, setAiSummary] = useAGState('');
  const [aiBusy, setAiBusy] = useAGState(false);

  const result = useAGMemo(() => window.SimEngine.evalQuery(query), [query]);

  const apiJson = useAGMemo(() => {
    if (!result) return null;
    return {
      version: 'gfa-pm-lab.v0.3',
      generatedAt: new Date().toISOString(),
      input: {
        query: query.map(g => ({ op: g.op, leaves: g.leaves })),
        target,
        exposure,
      },
      output: {
        예상도달인원: result.finalReach,
        월노출수: result.impressions,
        클릭률: result.ctr,
        노출당비용: result.cpm,
        전환율: result.conv,
        예상전환건수: result.convs,
        타겟정확도: result.validity,
        경쟁도: result.compete,
        월예상지출: result.budget,
        성별비율_여성: Math.round(result.skew * 100),
        연령분포: Object.fromEntries(window.SimEngine.AGES.map((a, i) => [a, +(result.ageDist[i]*100).toFixed(1)])),
        지면효과: Object.fromEntries(window.SimEngine.PLACEMENTS.map((p, i) => [p.label, +(result.placeNorm[i]*100).toFixed(1)])),
        시간대효과: Object.fromEntries(window.SimEngine.TIME_BINS.map((t, i) => [t.label, +(result.timeDist[i]*100).toFixed(1)])),
      },
    };
  }, [query, target, exposure, result]);

  function runTest() {
    setBusy(true);
    setOut('');
    const tests = [];
    function pass(name) { tests.push({ name, ok: true }); }
    function fail(name, why) { tests.push({ name, ok: false, why }); }

    try {
      const tx = window.GFAMatrix.taxonomy();
      if (tx.length > 0) pass('taxonomy 트리 로드'); else fail('taxonomy 트리 로드', '비어 있음');
    } catch (e) { fail('taxonomy 트리 로드', e.message); }

    try {
      const sample = [{ op: 'OR', leaves: ['관심사 > 뷰티 > 스킨케어', '관심사 > 뷰티 > 메이크업/색조'] }];
      const r = window.GFAMatrix.simulate(sample);
      if (r && r.finalReach > 0) pass('단순 OR 쿼리 시뮬레이션 (도달 > 0)');
      else fail('단순 OR 쿼리 시뮬레이션', '결과 비정상');
    } catch (e) { fail('단순 OR 쿼리 시뮬레이션', e.message); }

    try {
      const recs = window.GFAMatrix.recommend([{ op: 'OR', leaves: ['관심사 > 게임 > 모바일 게임'] }]);
      if (Array.isArray(recs) && recs.length >= 3) pass('추천 3종 생성');
      else fail('추천 3종 생성', `length=${recs?.length}`);
    } catch (e) { fail('추천 3종 생성', e.message); }

    try {
      const text = window.GFAMatrix.simulateText({
        leaves: ['관심사 > 라이프 이벤트 > 결혼'],
        op: 'OR',
      });
      if (text && text.length > 20) pass('자연어 요약 출력');
      else fail('자연어 요약 출력', '문자열 너무 짧음');
    } catch (e) { fail('자연어 요약 출력', e.message); }

    try {
      const ax = window.GFAMatrix.archetypes([{ op: 'OR', leaves: ['관심사 > 게임 > PC 게임'] }]);
      if (Array.isArray(ax) && ax.length === 6) pass('아키타입 6종 매칭');
      else fail('아키타입 6종 매칭', `len=${ax?.length}`);
    } catch (e) { fail('아키타입 6종 매칭', e.message); }

    try {
      const cmp = window.GFAMatrix.compare(
        [{ op: 'OR', leaves: ['관심사 > 뷰티 > 스킨케어'] }],
        [{ op: 'OR', leaves: ['관심사 > 게임 > PC 게임'] }]
      );
      if (cmp && cmp.diff) pass('두 쿼리 비교');
      else fail('두 쿼리 비교', 'diff 없음');
    } catch (e) { fail('두 쿼리 비교', e.message); }

    const allPass = tests.every(t => t.ok);
    setOut(JSON.stringify({ status: allPass ? 'PASS' : 'FAIL', tests }, null, 2));
    setBusy(false);
  }

  function copyJson() {
    if (!apiJson) return;
    window.safeCopy(JSON.stringify(apiJson, null, 2));
  }

  async function explainWithClaude() {
    if (!result || !window.claude?.complete) return;
    setAiBusy(true);
    setAiSummary('');
    try {
      const prompt = `당신은 디지털 광고 미디어 플래너입니다. 다음 네이버 GFA 광고 시뮬레이션 결과를 한국어로 3-4 문장 자연스럽게 해설해 주세요. 핵심 인사이트와 권장사항을 포함하고 마크다운/번호매김 없이 줄글로 답변하세요.\n\n${JSON.stringify(apiJson, null, 2)}`;
      const reply = await window.claude.complete(prompt);
      setAiSummary(reply);
    } catch (e) {
      setAiSummary('AI 호출 실패: ' + e.message);
    }
    setAiBusy(false);
  }

  return (
    <div style={{ padding: 18, display: 'flex', flexDirection: 'column', gap: 14 }} data-screen-label="06 Agent">
      <div className="panel">
        <div className="panel-head">
          <h3>현재 시뮬레이션 — JSON 출력<span className="tag">window.GFAMatrix.export()</span></h3>
          <div style={{ display: 'flex', gap: 6 }}>
            <button className="btn" data-size="sm" onClick={copyJson}>📋 복사</button>
          </div>
        </div>
        <div className="panel-body">
          <pre className="agent-pre">
{apiJson ? JSON.stringify(apiJson, null, 2) : '// 쿼리를 먼저 구성하세요'}
          </pre>
        </div>
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 14 }}>
        <div className="panel">
          <div className="panel-head">
            <h3>AI 자연어 해설<span className="tag">claude.complete</span></h3>
            <button className="btn" data-variant="primary" data-size="sm"
                    onClick={explainWithClaude} disabled={!result || aiBusy}>
              {aiBusy ? <><span className="spin"></span> 해설 생성 중…</> : '🪄 해설 요청'}
            </button>
          </div>
          <div className="panel-body">
            {aiSummary ? (
              <p style={{ fontSize: 14, lineHeight: 1.7, color: 'var(--text)', margin: 0 }}>
                {aiSummary}
              </p>
            ) : (
              <div style={{ color: 'var(--text-mute)', fontSize: 12 }}>
                🪄 버튼을 누르면 Claude가 현재 시뮬레이션 결과를 자연스러운 한국어로 해설합니다.
                <br/><br/>
                <strong>외부 에이전트 활용:</strong><br/>
                <code style={{ fontFamily: 'var(--font-mono)', fontSize: 11 }}>
                  const text = await window.GFAMatrix.simulateText({ leaves, op })
                </code>
              </div>
            )}
          </div>
        </div>

        <div className="panel">
          <div className="panel-head">
            <h3>자가 테스트<span className="tag">엔진 6종 점검</span></h3>
            <button className="btn" data-variant="primary" data-size="sm" onClick={runTest} disabled={busy}>
              {busy ? <><span className="spin"></span> 실행 중…</> : '▶ 테스트 실행'}
            </button>
          </div>
          <div className="panel-body">
            <pre className="agent-pre" style={{ maxHeight: 260 }}>{out || '// 테스트 실행 결과가 여기에 표시됩니다.\n// 에이전트가 페이지 로드 직후 GFAMatrix.runTests() 로 자동 점검할 수 있습니다.'}</pre>
          </div>
        </div>
      </div>

      <div className="panel">
        <div className="panel-head"><h3>에이전트 활용 가이드<span className="tag">API 레퍼런스</span></h3></div>
        <div className="panel-body" style={{ fontSize: 13, lineHeight: 1.7 }}>
          <p>이 페이지는 <strong>외부 LLM 에이전트가 직접 호출</strong>할 수 있도록 <code>window.GFAMatrix</code> 글로벌 API를 노출합니다.
            iframe에 페이지를 띄운 뒤 <code>eval_js</code> 또는 <code>postMessage</code>로 호출하세요.</p>
          <h4 style={{ color: 'var(--signal)', margin: '14px 0 6px' }}>주요 메서드</h4>
          <table className="api-tbl">
            <thead><tr><th>메서드</th><th>설명</th><th>반환값</th></tr></thead>
            <tbody>
              <tr><td><code>GFAMatrix.simulate(query)</code></td><td>쿼리 → 도달·CPM·CTR 등 전체 지표</td><td>객체</td></tr>
              <tr><td><code>GFAMatrix.simulateText(spec)</code></td><td>한국어 요약 1-2문장</td><td>문자열</td></tr>
              <tr><td><code>GFAMatrix.recommend(query)</code></td><td>확장·집중·다양화 3종 추천</td><td>배열[3]</td></tr>
              <tr><td><code>GFAMatrix.compare(qA, qB)</code></td><td>두 쿼리 핵심지표 차이</td><td>객체</td></tr>
              <tr><td><code>GFAMatrix.archetypes(query)</code></td><td>6개 페르소나 매칭 점수</td><td>배열[6]</td></tr>
              <tr><td><code>GFAMatrix.taxonomy()</code></td><td>560종 카테고리 트리</td><td>트리</td></tr>
              <tr><td><code>GFAMatrix.runTests()</code></td><td>엔진 자가진단</td><td>객체</td></tr>
              <tr><td><code>GFAMatrix.export()</code></td><td>현재 화면 시뮬레이션 결과 전체</td><td>객체</td></tr>
            </tbody>
          </table>

          <h4 style={{ color: 'var(--cyan)', margin: '14px 0 6px' }}>쿼리 구조</h4>
          <pre className="agent-pre" style={{ marginTop: 0 }}>
{`{
  "query": [
    { "op": "OR",  "leaves": ["관심사 > 뷰티 > 스킨케어", "관심사 > 뷰티 > 메이크업/색조"] },
    { "op": "AND", "leaves": ["관심사 > 라이프 이벤트 > 결혼"] }
  ]
}
// (A∪B) ∩ C 형태로 해석됨`}</pre>

          <h4 style={{ color: 'var(--plant)', margin: '14px 0 6px' }}>호출 예 — 클로드 에이전트 시점</h4>
          <pre className="agent-pre" style={{ marginTop: 0 }}>
{`// 1. 페이지를 iframe에 띄움
// 2. window.GFAMatrix 가 글로벌에 노출됨
const r = window.GFAMatrix.simulate([
  { op: 'OR', leaves: ['관심사 > 게임 > 모바일 게임'] }
]);
// r.finalReach → 예상 도달 인원
// r.validity   → 0~100 점 타겟 정확도
// r.recommendation → 자연어 한 줄 인사이트`}</pre>
        </div>
      </div>

      <style>{`
        .agent-pre {
          background: oklch(0.08 0.01 240 / 0.6);
          border: 1px solid rgba(255,240,220,0.08);
          padding: 10px 12px;
          font-family: var(--font-mono);
          font-size: 11px;
          line-height: 1.6;
          color: var(--bone-200);
          margin: 0;
          overflow: auto;
          max-height: 400px;
          white-space: pre;
        }
        .api-tbl {
          width: 100%;
          border-collapse: collapse;
          margin: 4px 0 12px;
        }
        .api-tbl th, .api-tbl td {
          text-align: left;
          padding: 6px 10px;
          border-bottom: 1px dashed var(--border);
          font-size: 12px;
        }
        .api-tbl th { color: var(--text-dim); font-weight: 500; font-size: 11px; }
        .api-tbl code {
          font-family: var(--font-mono);
          font-size: 11px;
          color: var(--signal);
          background: oklch(0.08 0.01 240 / 0.5);
          padding: 2px 6px;
        }
        code {
          font-family: var(--font-mono);
          font-size: 12px;
          color: var(--signal);
          background: oklch(0.08 0.01 240 / 0.4);
          padding: 1px 4px;
        }
      `}</style>
    </div>
  );
}

// === Install the public API on window =================================
function installGFAMatrixAPI() {
  const SE = window.SimEngine;
  if (!SE) return;

  function summarize(result) {
    if (!result) return '쿼리 결과가 없습니다.';
    const reach = SE.fmtN(result.finalReach);
    const v = result.validity;
    const c = result.compete;
    const fStr = v >= 70 ? '우수' : v >= 50 ? '양호' : '개선 필요';
    const cStr = c >= 70 ? '경합' : c >= 50 ? '중간' : '여유';
    return `예상 도달 ${reach}명, 클릭률 ${result.ctr}%, 전환율 ${result.conv}%, 노출당 비용 ₩${result.cpm.toLocaleString()}. 타겟 정확도 ${v}점(${fStr}), 경쟁도 ${c}점(${cStr}). 월 예상 지출 약 ${SE.fmtKRW(result.budget)}.`;
  }

  window.GFAMatrix = {
    version: 'gfa-pm-lab.v0.3',
    taxonomy() { return window.TAXONOMY; },
    leafCount() { return window.TOTAL_LEAVES; },
    simulate(query) {
      const r = SE.evalQuery(query);
      if (r) r.recommendation = summarize(r);
      return r;
    },
    simulateText({ leaves, op = 'OR' }) {
      const q = [{ op, leaves }];
      return summarize(SE.evalQuery(q));
    },
    recommend(query) { return SE.aiRecommend(query, window.TAXONOMY); },
    compare(qA, qB) {
      const a = SE.evalQuery(qA);
      const b = SE.evalQuery(qB);
      if (!a || !b) return null;
      const keys = ['finalReach', 'ctr', 'cpm', 'conv', 'validity', 'compete', 'budget'];
      const diff = {};
      for (const k of keys) {
        diff[k] = {
          A: a[k], B: b[k],
          delta: b[k] - a[k],
          pct: a[k] ? +((b[k] - a[k]) / a[k] * 100).toFixed(1) : null,
        };
      }
      return { A: a, B: b, diff };
    },
    archetypes(query) { return SE.rankArchetypes(query); },
    runTests() {
      const tests = [];
      try {
        const t = this.taxonomy();
        tests.push({ name: 'taxonomy', ok: t.length > 0 });
      } catch (e) { tests.push({ name: 'taxonomy', ok: false, err: e.message }); }
      try {
        const r = this.simulate([{ op: 'OR', leaves: ['관심사 > 뷰티 > 스킨케어'] }]);
        tests.push({ name: 'simulate', ok: r?.finalReach > 0 });
      } catch (e) { tests.push({ name: 'simulate', ok: false, err: e.message }); }
      try {
        const r = this.recommend([{ op: 'OR', leaves: ['관심사 > 게임 > PC 게임'] }]);
        tests.push({ name: 'recommend', ok: r.length === 3 });
      } catch (e) { tests.push({ name: 'recommend', ok: false, err: e.message }); }
      return { status: tests.every(t => t.ok) ? 'PASS' : 'FAIL', tests };
    },
    export() {
      // The most recent simulation rendered on screen
      const app = window.__currentApp;
      if (!app) return null;
      const r = SE.evalQuery(app.query);
      if (r) r.recommendation = summarize(r);
      return {
        version: 'gfa-pm-lab.v0.3',
        input: app,
        output: r,
      };
    },
  };
}

Object.assign(window, { AgentAPIView, installGFAMatrixAPI });
