const express = require('express');
const crypto = require('crypto');
const WebSocket = require('ws');

const app = express();
app.use(express.json());

const SIGMA_OMEGA = "Σ-Ω-184.5";
const VALID_SIGNATURE = "⟨ℏN⟩"; // Clé de test – en production : authentification multi-facteurs + signature cryptographique

class NATIOMÈTRE {
  constructor() {
    this.journal = []; // Append-only log
    this.setupAPI();
    this.setupWebSocket();
  }

  setupAPI() {
    app.post('/natiometre-command', (req, res) => {
      const { proposal, action, deltaPhi = 0, signature } = req.body;
      
      // Étape 1 : Vérification signature souveraine ⟨ℏN⟩
      if (signature !== VALID_SIGNATURE) {
        this._logRejection(proposal, 'Signature invalide');
        return res.status(403).json({ status: 'Rejeté', message: 'Signature ⟨ℏN⟩ requise' });
      }
      
      // Étape 2 : Traitement de l’action
      let correctedTauN = proposal.tauN;
      let command = { status: 'Validé', action };
      
      if (action === 'override') {
        correctedTauN += deltaPhi * 0.1; // Exemple : amplification simple
        command.correctedTauN = correctedTauN;
        command.message = `Override appliqué : Δϕ = ${deltaPhi}`;
      } else if (action === 'reject') {
        command.message = 'Proposition rejetée par autorité souveraine';
      }
      
      // Étape 3 : Scellage S.H.I.
      const serialized = JSON.stringify(command);
      const sealHash = crypto.createHash('sha256').update(serialized).digest('hex') + SIGMA_OMEGA;
      
      this._logCommand(command, sealHash);
      
      res.json({
        ...command,
        sealHash,
        executionTimeMs: 250
      });
    });
  }

  setupWebSocket() {
    const wss = new WebSocket.Server({ port: 3004 });
    wss.on('connection', (ws) => {
      console.log('C.T.I. connecté au NATIOMÈTRE');
      ws.on('message', (message) => {
        console.log('Commande reçue :', message);
      });
    });
  }

  _logRejection(proposal, reason) {
    this.journal.push({
      type: 'rejection',
      proposal,
      reason,
      timestamp: new Date().toISOString()
    });
  }

  _logCommand(command, sealHash) {
    this.journal.push({
      type: 'command',
      command,
      sealHash,
      timestamp: new Date().toISOString()
    });
  }

  start(port = 3003) {
    app.listen(port, () => {
      console.log(`NATIOMÈTRE API listening on port ${port}`);
    });
  }
}

// Exemple d'utilisation
const natioMetre = new NATIOMÈTRE();
natioMetre.start();

// Test avec fetch (simulé)
fetch('http://localhost:3003/natiometre-command', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    proposal: { tauN: 0.92, scenario: 'Phénix' },
    action: 'override',
    deltaPhi: 0.6,
    signature: '⟨ℏN⟩'
  })
})
.then(res => res.json())
.then(console.log);

// Exemple simplifié d’interface React (Next.js) – dashboard NATIOMÈTRE
import { useState, useEffect } from 'react';
import { Canvas } from '@react-three/fiber';
import { OrbitControls } from '@react-three/drei';

function Natiogramme3D({ tauN, phase }) {
  return (
    <Canvas>
      <ambientLight intensity={0.5} />
      <pointLight position={[10, 10, 10]} />
      <mesh>
        <torusKnotGeometry args={[1, 0.4, 100, 16]} />
        <meshStandardMaterial color={tauN > 0.95 ? 'green' : tauN > 0.8 ? 'yellow' : 'red'} />
      </mesh>
      <OrbitControls />
    </Canvas>
  );
}

export default function NatiometreDashboard() {
  const [proposal, setProposal] = useState(null);
  const [deltaPhi, setDeltaPhi] = useState(0);

  useEffect(() => {
    // Connexion WebSocket au NATIOTRON (simulé)
    const ws = new WebSocket('ws://localhost:3001/natiotron-proposal');
    ws.onmessage = (event) => {
      const data = JSON.parse(event.data);
      setProposal(data);
    };
    return () => ws.close();
  }, []);

  const handleOverride = async () => {
    const response = await fetch('/api/natiometre-override', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        proposal,
        action: 'override',
        deltaPhi,
        signature: '⟨ℏN⟩' // En production : signature cryptographique réelle
      })
    });
    const result = await response.json();
    console.log('Commande exécutée :', result);
  };

  return (
    <div style={{ height: '100vh', background: '#0a0a1f', color: 'white', padding: '2rem' }}>
      <h1>NATIOMÈTRE – Trône Souverain</h1>
      
      {proposal ? (
        <>
          <h2>Proposition NATIOTRON</h2>
          <p>τN actuel : {proposal.tauN.toFixed(2)}</p>
          <p>Scénario : {proposal.scenario}</p>
          
          <div style={{ height: '400px' }}>
            <Natiogramme3D tauN={proposal.tauN} phase={proposal.phase} />
          </div>
          
          <div>
            <label>Δϕ (correction phase) : </label>
            <input 
              type="number" 
              step="0.01" 
              value={deltaPhi} 
              onChange={(e) => setDeltaPhi(parseFloat(e.target.value))} 
            />
            <button onClick={handleOverride}>Override & Valider</button>
            <button onClick={() => alert('Rejet validé')}>Rejeter</button>
          </div>
        </>
      ) : (
        <p>En attente de proposition NATIOTRON...</p>
      )}
    </div>
  );
}