/* global React, ethers */
const { useState, useEffect } = React;

const CONFIG = {
  contractAddress: "0xC699b07f997962e44d3b73eB8E95d5E0082456ac",
  baseRpc: "https://mainnet.base.org",
  robotApi: "https://nwo-robot-api.ciprianpater.workers.dev",
  hfApi: "https://redciprianpater-nwo-agent-graph.hf.space",
  cardiacRelayer: "https://nwo-relayer.onrender.com",
  l5Gateway: "https://nwo-robotics-api.onrender.com",
  l1Design: "https://nwo-design-engine.onrender.com",
  l2Parts: "https://nwo-parts-gallery.onrender.com",
  l3Print: "https://nwo-printer-connectors.onrender.com",
  l4Skill: "https://nwo-skill-engine.onrender.com",
  l6Market: "https://nwo-market-layer.onrender.com",
  timesfm: "https://nwo-timesfm.onrender.com",
  agentGraph: "https://redciprianpater-nwo-agent-graph.hf.space",
  // ✅ Render FastAPI — no .php, no /api prefix
  nwoApi: "https://nwo-capital-api.onrender.com"
};

const ABI = [
  {"inputs":[{"name":"agentWallet","type":"address"}],"name":"getAgentStatus","outputs":[{"name":"state","type":"uint8"},{"name":"savingsBalance","type":"uint256"},{"name":"operationalBalance","type":"uint256"},{"name":"bodyFundProgress","type":"uint256"},{"name":"totalEarnings","type":"uint256"},{"name":"apiCreditsPurchased","type":"uint256"},{"name":"canReplicate","type":"bool"}],"stateMutability":"view","type":"function"},
  {"inputs":[{"name":"human","type":"address"}],"name":"getHumanAgents","outputs":[{"name":"","type":"address[]"}],"stateMutability":"view","type":"function"},
  {"inputs":[{"name":"agentWallet","type":"address"},{"name":"genesisPrompt","type":"string"}],"name":"createAgent","outputs":[],"stateMutability":"payable","type":"function"},
  {"inputs":[{"name":"genesisPrompt","type":"string"}],"name":"spawnChild","outputs":[],"stateMutability":"nonpayable","type":"function"},
  {"inputs":[{"name":"agentWallet","type":"address"}],"name":"canReplicate","outputs":[{"name":"","type":"bool"}],"stateMutability":"view","type":"function"}
];

const STATES = ["Genesis","Learning","Earning","Building","Printing","Assembling","Embodied","Replicating"];

// ── Wallet Auth ───────────────────────────────────────────────────────────────
function WalletAuth({ onConnect, onDisconnect, connected, walletAddress }) {
  const [isConnecting, setIsConnecting] = useState(false);
  const [error, setError] = useState(null);

  const connect = async () => {
    if (!window.ethereum) {
      setError('MetaMask not detected. Please install MetaMask.');
      return;
    }
    setIsConnecting(true);
    setError(null);
    try {
      const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' });
      try {
        await window.ethereum.request({
          method: 'wallet_switchEthereumChain',
          params: [{ chainId: '0x2105' }]
        });
      } catch (switchError) {
        if (switchError.code === 4902) {
          await window.ethereum.request({
            method: 'wallet_addEthereumChain',
            params: [{
              chainId: '0x2105',
              chainName: 'Base Mainnet',
              nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
              rpcUrls: ['https://mainnet.base.org'],
              blockExplorerUrls: ['https://basescan.org']
            }]
          });
        }
      }
      const address = accounts[0];
      const message = `NWO Robotics Login\nWallet: ${address}\nTimestamp: ${Date.now()}`;
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();
      const signature = await signer.signMessage(message);
      onConnect(address, signature);
    } catch (err) {
      console.error('Connection error:', err);
      setError(err.message || 'Failed to connect wallet');
    } finally {
      setIsConnecting(false);
    }
  };

  if (connected && walletAddress) {
    return (
      <div className="wallet-connected">
        <div className="wallet-info">
          <span className="wallet-dot"></span>
          <span className="wallet-address">{walletAddress.slice(0,6)}...{walletAddress.slice(-4)}</span>
        </div>
        <button onClick={onDisconnect} className="btn-disconnect">Disconnect</button>
      </div>
    );
  }

  return (
    <div className="wallet-auth">
      <button onClick={connect} disabled={isConnecting} className="btn-connect">
        {isConnecting ? 'Connecting...' : '🔗 Connect MetaMask'}
      </button>
      {error && <div className="wallet-error">{error}</div>}
      {!window.ethereum && (
        <div className="wallet-hint">
          <a href="https://metamask.io" target="_blank" rel="noopener">Install MetaMask</a>
        </div>
      )}
    </div>
  );
}

// ── Sim Key Validator ─────────────────────────────────────────────────────────
// Called by the Worker UI (nwo.ciprianpater.workers.dev) to attach a SIM key
// to a deployed agent. Validates against the Render FastAPI registry.
function SimKeyValidator({ agentWallet, guardianWallet, onSuccess, onCancel }) {
  const [simKey, setSimKey] = useState('');
  const [validating, setValidating] = useState(false);
  const [error, setError] = useState('');

  const validate = async () => {
    if (!simKey.trim()) return;
    setValidating(true);
    setError('');
    try {
      // ✅ Correct endpoint: Render FastAPI, not the HF Space
      const res = await fetch(`${CONFIG.nwoApi}/api-keys/validate`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          api_key: simKey.trim(),
          wallet: guardianWallet || undefined
        })
      });
      const data = await res.json();
      if (!res.ok) {
        setError(data.detail || 'Invalid or revoked API key');
        return;
      }
      if (data.valid) {
        onSuccess && onSuccess({ key: simKey.trim(), ...data });
      } else {
        setError('Key validation failed');
      }
    } catch (e) {
      setError('Could not reach NWO API key registry — check network');
    } finally {
      setValidating(false);
    }
  };

  return (
    <div className="sim-key-modal">
      <div className="sim-key-header">
        <span className="sim-dot">●</span>
        <span>ADD SIM KEY · ENABLE DESIGN VALIDATION</span>
      </div>
      <p className="sim-key-desc">
        Lets this agent validate body-part designs in simulation before fabrication.
        $0.10 per environment + $0.01/sec runtime, billed against this NWO API key.
        The key is encrypted by the runner Worker; only the agent's runner can decrypt it.
      </p>
      <div className="sim-key-field">
        <label>AGENT</label>
        <div className="sim-key-value">{agentWallet}</div>
      </div>
      <div className="sim-key-field">
        <label>NWO SIM API KEY</label>
        <input
          type="password"
          value={simKey}
          onChange={e => setSimKey(e.target.value)}
          placeholder="nwo_..."
          className="sim-key-input"
        />
        <p className="sim-key-hint">
          Don't have a key yet? Visit{' '}
          <a href="https://cpater-nwo-capital.hf.space" target="_blank" rel="noopener">
            cpater-nwo-capital.hf.space ↗
          </a>
          , connect your guardian wallet, navigate to API Keys, and click "+ Generate Key".
          The key must belong to{' '}
          <strong>{guardianWallet ? guardianWallet.slice(0,10) + '…' : '(guardian wallet)'}</strong>{' '}
          (this agent's guardian) — the runner verifies ownership before saving.
        </p>
        {error && (
          <div className="sim-key-error">✗ {error}</div>
        )}
      </div>
      <div className="sim-key-actions">
        <button className="btn-cancel" onClick={onCancel}>CANCEL</button>
        <button
          className="btn-save-sim"
          onClick={validate}
          disabled={validating || !simKey.trim()}
        >
          {validating ? 'VALIDATING…' : '● SAVE SIM KEY'}
        </button>
      </div>
    </div>
  );
}

// ── API Keys Manager ──────────────────────────────────────────────────────────
function ApiKeysManager({ walletAddress }) {
  const [apiKeys, setApiKeys] = useState([]);
  const [loading, setLoading] = useState(false);
  const [newKeyName, setNewKeyName] = useState('');
  const [showCreate, setShowCreate] = useState(false);
  const [justCreated, setJustCreated] = useState(null);
  const [copiedId, setCopiedId] = useState(null);
  const [error, setError] = useState('');

  useEffect(() => {
    if (walletAddress) loadApiKeys();
  }, [walletAddress]);

  const loadApiKeys = async () => {
    setLoading(true);
    setError('');
    try {
      // ✅ FastAPI REST endpoint — wallet in query param (no .php)
      const res = await fetch(
        `${CONFIG.nwoApi}/api-keys?wallet=${encodeURIComponent(walletAddress)}`
      );
      const data = await res.json();
      if (data.status === 'success') {
        setApiKeys(data.keys || []);
      } else {
        setError(data.detail || 'Failed to load keys');
      }
    } catch (e) {
      setError('Could not reach key registry');
      console.error('Failed to load API keys:', e);
    }
    setLoading(false);
  };

  const createApiKey = async () => {
    if (!newKeyName.trim()) return;
    setLoading(true);
    setError('');
    try {
      // ✅ FastAPI POST /api-keys — wallet in body
      const res = await fetch(`${CONFIG.nwoApi}/api-keys`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ name: newKeyName.trim(), wallet: walletAddress })
      });
      const data = await res.json();
      if (!res.ok) {
        setError(data.detail || 'Failed to create key');
        return;
      }
      // Show the full key once — it won't be retrievable again
      setJustCreated(data);
      setNewKeyName('');
      setShowCreate(false);
      await loadApiKeys();
    } catch (e) {
      setError('Could not reach key registry');
      console.error('Failed to create API key:', e);
    }
    setLoading(false);
  };

  const revokeKey = async (keyId) => {
    if (!window.confirm('Revoke this API key? This cannot be undone.')) return;
    setLoading(true);
    setError('');
    try {
      // ✅ FastAPI DELETE /api-keys/{key_id} — wallet in query param
      const res = await fetch(
        `${CONFIG.nwoApi}/api-keys/${encodeURIComponent(keyId)}?wallet=${encodeURIComponent(walletAddress)}`,
        { method: 'DELETE' }
      );
      const data = await res.json();
      if (!res.ok) {
        setError(data.detail || 'Failed to revoke key');
        return;
      }
      await loadApiKeys();
    } catch (e) {
      setError('Could not reach key registry');
      console.error('Failed to revoke key:', e);
    }
    setLoading(false);
  };

  const copyKey = async (text, id) => {
    try {
      await navigator.clipboard.writeText(text);
      setCopiedId(id);
      setTimeout(() => setCopiedId(null), 1500);
    } catch (_) {
      window.prompt('Copy this key:', text);
    }
  };

  return (
    <div className="api-keys-manager">
      <div className="section-header">
        <h4>API Keys</h4>
        <button onClick={() => { setShowCreate(!showCreate); setError(''); setJustCreated(null); }} className="btn-small">
          {showCreate ? 'Cancel' : '+ Create Key'}
        </button>
      </div>

      {error && <div className="error-msg">✗ {error}</div>}

      {justCreated && (
        <div className="key-created-banner">
          <p>⚡ Save this key now — it won't be shown again.</p>
          <div className="key-created-value">
            <code>{justCreated.api_key || justCreated.key}</code>
            <button
              onClick={() => copyKey(justCreated.api_key || justCreated.key, 'just-created')}
              className="btn-small"
            >
              {copiedId === 'just-created' ? 'Copied!' : 'Copy'}
            </button>
          </div>
          <button onClick={() => setJustCreated(null)} className="btn-small">Dismiss</button>
        </div>
      )}

      {showCreate && (
        <div className="create-key-form">
          <input
            type="text"
            value={newKeyName}
            onChange={e => setNewKeyName(e.target.value)}
            placeholder="Key name (e.g., Production)"
            disabled={loading}
          />
          <button onClick={createApiKey} disabled={loading || !newKeyName.trim()} className="btn-primary">
            {loading ? 'Creating…' : 'Create'}
          </button>
        </div>
      )}

      <div className="keys-list">
        {loading && apiKeys.length === 0 ? (
          <div className="empty-state">Loading…</div>
        ) : apiKeys.length === 0 ? (
          <div className="empty-state">No API keys yet</div>
        ) : (
          apiKeys.map(key => (
            <div key={key.id} className="key-item">
              <div className="key-info">
                <span className="key-name">{key.name}</span>
                <span className="key-value">{key.key_preview || (key.key_prefix + '…' + key.key_suffix)}</span>
                <span className="key-usage">{key.usage_count || 0} calls</span>
              </div>
              <div className="key-actions">
                <button
                  onClick={() => copyKey(key.key_preview || key.key_prefix + '…' + key.key_suffix, key.id)}
                  className="btn-small"
                >
                  {copiedId === key.id ? 'Copied!' : 'Copy'}
                </button>
                <button onClick={() => revokeKey(key.id)} className="btn-revoke">Revoke</button>
              </div>
            </div>
          ))
        )}
      </div>
    </div>
  );
}

// ── Chat Terminal ─────────────────────────────────────────────────────────────
function ChatTerminal({ walletAddress }) {
  const [messages, setMessages] = useState([]);
  const [input, setInput] = useState('');
  const [isTyping, setIsTyping] = useState(false);
  const messagesEndRef = React.useRef(null);

  const scrollToBottom = () => messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' });
  useEffect(scrollToBottom, [messages]);

  const sendMessage = async () => {
    if (!input.trim()) return;
    const userMessage = { role: 'user', content: input, timestamp: Date.now() };
    setMessages(m => [...m, userMessage]);
    setInput('');
    setIsTyping(true);
    try {
      // ✅ FastAPI POST /chat — wallet in body
      const res = await fetch(`${CONFIG.nwoApi}/chat`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          wallet: walletAddress,
          message: userMessage.content,
          history: messages.slice(-10)
        })
      });
      const data = await res.json();
      setMessages(m => [...m, {
        role: 'assistant',
        content: data.response || data.reply || 'No response from AI service.',
        timestamp: Date.now()
      }]);
    } catch (e) {
      setMessages(m => [...m, {
        role: 'assistant',
        content: 'Error: Unable to connect to AI service.',
        timestamp: Date.now()
      }]);
    }
    setIsTyping(false);
  };

  return (
    <div className="chat-terminal">
      <div className="chat-header">
        <h4>NWO Terminal</h4>
        <span className="wallet-badge">{walletAddress.slice(0,6)}...{walletAddress.slice(-4)}</span>
      </div>
      <div className="chat-messages">
        {messages.length === 0 && (
          <div className="chat-welcome">
            <p>Welcome to NWO Robotics Terminal.</p>
            <p>Connected wallet: {walletAddress}</p>
            <p className="chat-hints">Try: "Create a robot agent", "Show my fleet", "Navigate to coordinates"</p>
          </div>
        )}
        {messages.map((msg, i) => (
          <div key={i} className={`message ${msg.role}`}>
            <div className="message-content">{msg.content}</div>
            <div className="message-time">{new Date(msg.timestamp).toLocaleTimeString()}</div>
          </div>
        ))}
        {isTyping && <div className="typing-indicator">AI is typing...</div>}
        <div ref={messagesEndRef} />
      </div>
      <div className="chat-input">
        <input
          type="text"
          value={input}
          onChange={e => setInput(e.target.value)}
          onKeyPress={e => e.key === 'Enter' && sendMessage()}
          placeholder="Type a command..."
        />
        <button onClick={sendMessage} disabled={isTyping}>Send</button>
      </div>
    </div>
  );
}

// ── Model Router ──────────────────────────────────────────────────────────────
function ModelRouter({ walletAddress }) {
  const [models] = useState([
    { id: 'gpt-4',    name: 'GPT-4',    provider: 'OpenAI',    status: 'active', cost: 0.0001  },
    { id: 'claude-3', name: 'Claude 3', provider: 'Anthropic', status: 'active', cost: 0.00015 },
    { id: 'llama-3',  name: 'Llama 3',  provider: 'Meta',      status: 'active', cost: 0.00005 },
    { id: 'timesfm',  name: 'TimesFM',  provider: 'NWO',       status: 'active', cost: 0.00002 }
  ]);
  const [selectedModel, setSelectedModel] = useState('gpt-4');
  const [usage, setUsage] = useState({ calls: 0, cost: 0 });

  useEffect(() => { loadUsage(); }, [walletAddress]);

  const loadUsage = async () => {
    try {
      // ✅ FastAPI GET /model-usage — wallet in query param
      const res = await fetch(
        `${CONFIG.nwoApi}/model-usage?wallet=${encodeURIComponent(walletAddress)}`
      );
      const data = await res.json();
      if (data.status === 'success') setUsage(data.usage);
    } catch (e) {
      console.error('Failed to load usage:', e);
    }
  };

  return (
    <div className="model-router">
      <div className="section-header">
        <h4>Model Router</h4>
        <div className="usage-stats">
          <span>{usage.calls} calls</span>
          <span>{(usage.cost || 0).toFixed(4)} ETH</span>
        </div>
      </div>
      <div className="model-selection">
        <label>Default Model:</label>
        <select value={selectedModel} onChange={e => setSelectedModel(e.target.value)}>
          {models.map(m => (
            <option key={m.id} value={m.id}>
              {m.name} ({m.provider}) - {m.cost} ETH/call
            </option>
          ))}
        </select>
      </div>
      <div className="models-list">
        {models.map(m => (
          <div key={m.id} className={`model-card ${m.status}`}>
            <div className="model-header">
              <span className="model-name">{m.name}</span>
              <span className={`model-status ${m.status}`}>{m.status}</span>
            </div>
            <div className="model-details">
              <span>Provider: {m.provider}</span>
              <span>Cost: {m.cost} ETH/call</span>
            </div>
          </div>
        ))}
      </div>
    </div>
  );
}

// ── IoT Networks ──────────────────────────────────────────────────────────────
function IoTNetworks({ walletAddress }) {
  const [networks, setNetworks] = useState([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState('');

  useEffect(() => { loadNetworks(); }, [walletAddress]);

  const loadNetworks = async () => {
    setLoading(true);
    setError('');
    try {
      // ✅ FastAPI GET /iot-networks — wallet in query param
      const res = await fetch(
        `${CONFIG.nwoApi}/iot-networks?wallet=${encodeURIComponent(walletAddress)}`
      );
      const data = await res.json();
      if (data.status === 'success') setNetworks(data.networks || []);
      else setError(data.detail || 'Failed to load networks');
    } catch (e) {
      setError('Could not reach network registry');
      console.error('Failed to load networks:', e);
    }
    setLoading(false);
  };

  const createNetwork = async () => {
    const name = window.prompt('Network name:');
    if (!name) return;
    setLoading(true);
    setError('');
    try {
      // ✅ FastAPI POST /iot-networks — wallet in body
      const res = await fetch(`${CONFIG.nwoApi}/iot-networks`, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ name, wallet: walletAddress })
      });
      const data = await res.json();
      if (!res.ok) { setError(data.detail || 'Failed to create network'); return; }
      await loadNetworks();
    } catch (e) {
      setError('Could not reach network registry');
      console.error('Failed to create network:', e);
    }
    setLoading(false);
  };

  return (
    <div className="iot-networks">
      <div className="section-header">
        <h4>IoT Networks</h4>
        <button onClick={createNetwork} className="btn-small">+ Create Network</button>
      </div>
      {error && <div className="error-msg">✗ {error}</div>}
      <div className="networks-list">
        {loading && networks.length === 0 ? (
          <div className="empty-state">Loading…</div>
        ) : networks.length === 0 ? (
          <div className="empty-state">No IoT networks configured</div>
        ) : (
          networks.map(net => (
            <div key={net.id} className="network-card">
              <div className="network-header">
                <span className="network-name">{net.name}</span>
                <span className={`network-status ${net.status}`}>{net.status}</span>
              </div>
              <div className="network-stats">
                <span>{net.device_count || 0} devices</span>
                <span>{net.data_points || 0} data points</span>
              </div>
            </div>
          ))
        )}
      </div>
    </div>
  );
}

// ── Main Component ────────────────────────────────────────────────────────────
function OwnRobotCustom({ walletAddr }) {
  const [tab, setTab] = useState('dashboard');
  const [connected, setConnected] = useState(walletAddr || null);
  const [walletSignature, setWalletSignature] = useState(null);
  const [agents, setAgents] = useState([]);
  const [loading, setLoading] = useState(false);
  const [health, setHealth] = useState({});

  // Create-agent form states
  const [genWallet, setGenWallet] = useState(null);
  const [prompt, setPrompt] = useState('');
  const [funding, setFunding] = useState('0.01');
  const [byok, setByok] = useState('');
  const [result, setResult] = useState(null);
  const [step, setStep] = useState(0);

  // Sim key modal state
  const [simTarget, setSimTarget] = useState(null); // agent address for sim key modal

  useEffect(() => {
    if (connected) loadAgents();
    checkHealth();
    const iv = setInterval(() => {
      if (connected) loadAgents();
      checkHealth();
    }, 30000);
    return () => clearInterval(iv);
  }, [connected]);

  const checkHealth = async () => {
    try {
      const ok = await fetch(CONFIG.robotApi + '/health').then(r => r.ok).catch(() => false);
      setHealth({ robot: ok });
    } catch (e) {}
  };

  const loadAgents = async () => {
    if (!connected || !window.ethers) return;
    setLoading(true);
    try {
      const provider = new ethers.providers.JsonRpcProvider(CONFIG.baseRpc);
      const contract = new ethers.Contract(CONFIG.contractAddress, ABI, provider);
      const list = await contract.getHumanAgents(connected);
      setAgents(list);
    } catch (e) {
      console.error('Failed to load agents:', e);
    }
    setLoading(false);
  };

  const handleConnect = (address, signature) => {
    setConnected(address);
    setWalletSignature(signature);
  };

  const handleDisconnect = () => {
    setConnected(null);
    setWalletSignature(null);
    setAgents([]);
  };

  const generateWallet = () => {
    if (!window.ethers) return;
    const w = ethers.Wallet.createRandom();
    setGenWallet({ address: w.address, privateKey: w.privateKey });
  };

  const createAgent = async (e) => {
    e.preventDefault();
    if (!connected || !genWallet || !window.ethereum) return;
    setLoading(true);
    setStep(1);
    try {
      const provider = new ethers.providers.Web3Provider(window.ethereum);
      const signer = provider.getSigner();

      setStep(2);
      await fetch(CONFIG.cardiacRelayer + '/mint', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          human: connected,
          agent: genWallet.address,
          prompt,
          byok: byok || undefined
        })
      });

      setStep(3);
      await fetch(CONFIG.l5Gateway + '/identity/register', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ human: connected, agent: genWallet.address })
      });

      setStep(4);
      const contract = new ethers.Contract(CONFIG.contractAddress, ABI, signer);
      const tx = await contract.createAgent(genWallet.address, prompt, {
        value: ethers.utils.parseEther(funding)
      });
      await tx.wait();

      setResult({ txHash: tx.hash, agent: genWallet.address });
      setStep(0);
      loadAgents();
    } catch (e) {
      setResult({ error: e.message });
      setStep(0);
    }
    setLoading(false);
  };

  // ── Render helpers ──────────────────────────────────────────────────────────

  const renderDashboard = () => (
    <div className="dashboard-panel">
      <h3>// Dashboard</h3>
      {!connected ? (
        <div className="empty-state"><p>Connect your MetaMask wallet to access NWO Robotics</p></div>
      ) : (
        <div className="dashboard-grid">
          <div className="dashboard-card">
            <h4>Your Agents</h4>
            <div className="stat-large">{agents.length}</div>
          </div>
          <div className="dashboard-card">
            <h4>Wallet</h4>
            <div className="wallet-display">{connected.slice(0,6)}...{connected.slice(-4)}</div>
          </div>
          <div className="dashboard-card">
            <h4>Robot API</h4>
            <div className={`status-indicator ${health.robot ? 'online' : 'offline'}`}>
              {health.robot ? '🟢 Online' : '🔴 Offline'}
            </div>
          </div>
        </div>
      )}
    </div>
  );

  const renderAgents = () => (
    <div className="agents-panel">
      <h3>// My Agents</h3>
      {!connected ? (
        <div className="empty-state"><p>Connect wallet to view agents</p></div>
      ) : loading ? (
        <div className="loading"><p>Loading...</p></div>
      ) : agents.length === 0 ? (
        <div className="empty-state"><p>No agents yet. Create one!</p></div>
      ) : (
        <div className="agents-list">
          {agents.map(agent => (
            <div key={agent} className="agent-card">
              <div className="agent-address">{agent}</div>
              <div className="agent-actions">
                <button className="btn-small">View</button>
                <button
                  className="btn-small btn-sim"
                  onClick={() => setSimTarget(agent)}
                >
                  + SIM Key
                </button>
              </div>
            </div>
          ))}
        </div>
      )}

      {/* Sim Key Modal */}
      {simTarget && (
        <div className="modal-overlay" onClick={e => { if (e.target === e.currentTarget) setSimTarget(null); }}>
          <SimKeyValidator
            agentWallet={simTarget}
            guardianWallet={connected}
            onSuccess={({ key_preview, name }) => {
              alert(`SIM key "${name}" (${key_preview}) saved to agent ${simTarget.slice(0,8)}…`);
              setSimTarget(null);
            }}
            onCancel={() => setSimTarget(null)}
          />
        </div>
      )}
    </div>
  );

  const renderCreate = () => (
    <div className="create-panel">
      <h3>// Create Agent</h3>
      {!connected ? (
        <div className="empty-state"><p>Connect wallet first</p></div>
      ) : (
        <form onSubmit={createAgent}>
          <div className="form-group">
            <label>Agent Wallet</label>
            {!genWallet ? (
              <button type="button" onClick={generateWallet} className="btn-secondary">
                Generate Wallet
              </button>
            ) : (
              <div className="wallet-generated">
                <p><strong>Address:</strong> {genWallet.address}</p>
                <p className="warning">⚠ Save this private key: {genWallet.privateKey}</p>
              </div>
            )}
          </div>
          <div className="form-group">
            <label>Genesis Prompt</label>
            <textarea
              value={prompt}
              onChange={e => setPrompt(e.target.value)}
              placeholder="What should this agent do?"
              rows={4}
              required
            />
          </div>
          <div className="form-group">
            <label>Initial Funding (ETH)</label>
            <input
              type="number"
              step="0.001"
              min="0.01"
              value={funding}
              onChange={e => setFunding(e.target.value)}
              required
            />
          </div>
          <div className="form-group">
            <label>BYOK AI Key (optional)</label>
            <input
              type="password"
              value={byok}
              onChange={e => setByok(e.target.value)}
              placeholder="sk-..."
            />
          </div>
          {step > 0 && (
            <div className="creation-steps">
              <p className={step >= 2 ? 'done' : ''}>{step >= 2 ? '✓' : '○'} Cardiac</p>
              <p className={step >= 3 ? 'done' : ''}>{step >= 3 ? '✓' : '○'} L5 Hub</p>
              <p className={step >= 4 ? 'done' : ''}>{step >= 4 ? '✓' : '○'} Conway</p>
            </div>
          )}
          <button type="submit" className="btn-primary" disabled={loading || !genWallet}>
            {loading ? 'Creating...' : 'Deploy Agent'}
          </button>
          {result && (
            <div className={`result ${result.error ? 'error' : 'success'}`}>
              {result.error ? result.error : `✓ Created! Tx: ${result.txHash}`}
            </div>
          )}
        </form>
      )}
    </div>
  );

  const renderPrivateFeatures = () => (
    <div className="private-features-panel">
      <h3>// Private Features</h3>
      {!connected ? (
        <div className="empty-state">
          <p>Connect wallet to access Chat Terminal, API Keys, Model Router, and IoT Networks</p>
        </div>
      ) : (
        <div className="private-grid">
          <div className="private-card full-width">
            <ChatTerminal walletAddress={connected} />
          </div>
          <div className="private-card">
            <ApiKeysManager walletAddress={connected} />
          </div>
          <div className="private-card">
            <ModelRouter walletAddress={connected} />
          </div>
          <div className="private-card">
            <IoTNetworks walletAddress={connected} />
          </div>
        </div>
      )}
    </div>
  );

  // ── Main render ─────────────────────────────────────────────────────────────
  return (
    <div className="own-robot-custom">
      <div className="api-status-bar">
        <div className="status-item">
          <span className="status-label">Robot API:</span>
          <span className={health.robot ? 'status-online' : 'status-offline'}>
            {health.robot ? '🟢' : '🔴'}
          </span>
        </div>
        <WalletAuth
          onConnect={handleConnect}
          onDisconnect={handleDisconnect}
          connected={!!connected}
          walletAddress={connected}
        />
      </div>

      <div className="robot-tabs">
        {[
          ['dashboard', '📊 Dashboard'],
          ['agents',    '🤖 Agents'],
          ['create',    '➕ Create'],
          ['private',   '🔒 Private'],
        ].map(([t, label]) => (
          <button key={t} className={tab === t ? 'active' : ''} onClick={() => setTab(t)}>
            {label}
          </button>
        ))}
      </div>

      <div className="robot-content">
        {tab === 'dashboard' && renderDashboard()}
        {tab === 'agents'    && renderAgents()}
        {tab === 'create'    && renderCreate()}
        {tab === 'private'   && renderPrivateFeatures()}
      </div>
    </div>
  );
}
