#!/usr/bin/env python3
"""CorvOS v2.1-Sigma - Sistema Integrado Completo"""
import numpy as np
from scipy.linalg import eig
from dataclasses import dataclass
from typing import List, Dict, Tuple, Optional
from datetime import datetime, timedelta
from enum import Enum
import asyncio, hashlib, random, sys, os
sys.path.insert(0, os.path.dirname(__file__))
from quantum_security_shield import *
from temporal_audit import *
from bio_link import *

HAPPINESS_SECTORS = ['Material','Social','Cultural','Espiritual','Ecologico']
TRANSITION_MATRIX = np.array([
    [0.85,0.08,0.04,0.02,0.01],
    [0.06,0.82,0.07,0.03,0.02],
    [0.03,0.09,0.80,0.05,0.03],
    [0.02,0.05,0.08,0.83,0.02],
    [0.01,0.03,0.05,0.04,0.87]
], dtype=np.float64)

@dataclass
class DistrictState:
    name: str
    happiness_vector: np.ndarray
    lambda2: float
    sensors_online: int
    attack_active: bool = False

class HappinessMatrix:
    def __init__(self):
        self.M = TRANSITION_MATRIX
        evals, evecs = eig(self.M)
        self.spectral_radius = max(abs(evals))
        self.eigenvalues = sorted(evals, key=abs, reverse=True)
        self.governance_vector = np.array([0.85,0.88,0.91,0.93,0.96])
    def apply_transition(self, current):
        return self.M @ current
    def compute_growth_rate(self):
        return 100*(self.spectral_radius-1.0)
    def simulate_year(self, years=1):
        state = self.governance_vector.copy()
        history=[state]
        for _ in range(years):
            state=self.apply_transition(state)
            history.append(state.copy())
        return history

class TemporalDirection(Enum):
    CAUSAL='causal'
    RETROCAUSAL='retrocausal'
    BIDIRECTIONAL='bidirectional'

@dataclass
class TemporalPacket:
    payload: np.ndarray
    timestamp_origin: datetime
    direction: any
    latency_ms: float
    lambda2: float
    hash: str

class RetrocausalARQ:
    RETROCAUSAL_WINDOW_MS=2.17
    def __init__(self):
        self.pending_packets={}
        self.pre_ack_cache={}
        self.packet_counter=0
    def create_packet(self, payload, direction):
        self.packet_counter+=1
        now=datetime.now()
        h=hashlib.sha256(payload.tobytes()+now.isoformat().encode()).hexdigest()[:24]
        if direction==TemporalDirection.RETROCAUSAL:
            latency=-abs(random.gauss(self.RETROCAUSAL_WINDOW_MS,0.3))
        elif direction==TemporalDirection.BIDIRECTIONAL:
            latency=random.choice([-1,1])*abs(random.gauss(1.0,0.5))
        else:
            latency=abs(random.gauss(2.0,0.5))
        return TemporalPacket(
            payload=payload,timestamp_origin=now,direction=direction,
            latency_ms=latency,lambda2=0.999,hash=h)
    async def transmit(self, packet):
        await asyncio.sleep(0.01)
        if packet.direction==TemporalDirection.RETROCAUSAL:
            return {'status':'TRANSMITTED','direction':'RETROCAUSAL','latency_ms':round(packet.latency_ms,2),'lambda2':round(packet.lambda2,6)}
        return {'status':'TRANSMITTED','direction':'CAUSAL','latency_ms':round(packet.latency_ms,2),'lambda2':0.998}

class NAREEngine:
    def __init__(self):
        self.H0_base=np.diag([1.0,0.618,0.382])
        self.Gamma_gain=np.diag([0.02,0.0,-0.01])
        self.current_H_eff=None
        self.ep_count=0
        self.lambda2_history=[]
    def compute_H_eff(self, reward):
        H0=self.H0_base.copy()
        H0+=reward*0.01*np.ones_like(H0)
        H_anti=(self.Gamma_gain-self.Gamma_gain.T.conj())/2
        return H0+1j*H_anti
    def compute_lambda2(self, H_eff):
        evals=np.linalg.eigvalsh(H_eff.real)
        if len(evals)>=2:
            sl=sorted(evals,reverse=True)[1]
            return min(0.9999,max(0.0,1.0-abs(sl-1.0)))
        return 0.5
    async def optimize_step(self, reward):
        self.current_H_eff=self.compute_H_eff(reward)
        self.lambda2_history.append(self.compute_lambda2(self.current_H_eff))
        if len(self.lambda2_history)>=2:
            if abs(self.lambda2_history[-1]-self.lambda2_history[-2])<0.0001:
                self.ep_count+=1
        return self.lambda2_history[-1]

class CorvOSv2:
    VERSION='2.1-Sigma'
    def __init__(self):
        self.happiness=HappinessMatrix()
        self.arq=RetrocausalARQ()
        self.nare=NAREEngine()
        self.security=QuantumSecurityShield()
        self.audit=TemporalAuditEngine()
        self.biolink=BioLinkPulseEngine()
        self.districts=[]
        self.sim_time=datetime.now()
        self.attack_scenario_active=False
        self._init_districts()
        self._init_biolink()
    def _init_districts(self):
        names=['Lagoa','Humaita','Botafogo','Leme','Flamengo','Urca']
        base_happiness=[0.72,0.68,0.85,0.65,0.79,0.82]
        for name,bh in zip(names,base_happiness):
            self.districts.append(DistrictState(name=name,happiness_vector=np.array([bh]*5),lambda2=0.999,sensors_online=168))
    def _init_biolink(self):
        for i in range(13000):
            rid=f'RES-{i:05d}'
            hr=random.uniform(60,80)
            self.biolink.register_resident(rid,hr)
    async def init(self):
        print('='*70)
        print('  CORVOS v2.1-Sigma - SISTEMA INTEGRADO COMPLETO')
        print('  ASI-EVOLVE + qhttp:// + NARE + Bio-Link + Security Shield')
        print('  Synapse-k | Arkhe(n) | Rio de Janeiro')
        print('='*70)
        ev_str=', '.join([f'{e:.4f}' for e in self.happiness.eigenvalues[:3]])
        print(f'[INIT] Autovalores: [{ev_str}]')
        print(f'[INIT] Raio espectral: {self.happiness.spectral_radius:.6f}')
        print(f'[INIT] Crescimento: {self.happiness.compute_growth_rate():.3f}%')
        print(f'[INIT] Bio-Link residentes: {len(self.biolink.residents)}')
        return self
    async def deploy(self):
        print('[DEPLOY] Sistema operacional | 6 distritos | 168 sensores NV')
    async def run_attack_simulation(self):
        print('='*70)
        print('  SIMULACAO DE ATAQUE COORDENADO - 168 SENSORES NV')
        print('='*70)
        self.attack_scenario_active=True
        normal_phases=np.random.normal(0,0.05,168)
        status=await self.security.process_sensor_readings(normal_phases,0.999)
        print(f'  [FASE1-NORMAL] Lambda=0.999 | Ataque={status["attack_detected"]} | Integridade={self.security.get_security_status()["system_integrity"]:.3f}')
        print('  [FASE2-ATAQUE] Injetando decoerencia+spoofing em 55 sensores...')
        attack_phases=np.random.normal(0,0.05,168)
        for i in range(30): attack_phases[i]=np.random.uniform(3.0,3.5)
        degraded_lambda=0.85
        for cycle in range(13):
            status=await self.security.process_sensor_readings(attack_phases,degraded_lambda)
            print(f'    Ciclo {cycle+1:02d}: Ataque={status["attack_detected"]} | Bloqueados={status["blocked_sensors"]} | {status["mitigation"]}')
            await asyncio.sleep(0.05)
        sec=self.security.get_security_status()
        print(f'  [FASE3-POS] Eventos={sec["total_events"]} | Bloqueados={sec["blocked_sensors"]} | Integridade={sec["system_integrity"]:.4f}')
        self.attack_scenario_active=False
    async def run_temporal_audit_demo(self):
        print('='*70)
        print('  AUDITORIA TEMPORAL - Tentativas de manipulacao')
        print('='*70)
        pkts=[
            {'node_id':'TZ-001','direction':'retrocausal','altered_fields':[],'target_time':datetime.now()+timedelta(days=365)},
            {'node_id':'TZ-002','direction':'retrocausal','altered_fields':['happiness_vector'],'target_time':datetime.now()+timedelta(days=365)},
            {'node_id':'TZ-003','direction':'causal','altered_fields':[],'target_time':None},
        ]
        for pkt in pkts:
            ok,entry=await self.audit.audit_packet(pkt,pkt['direction'])
            status='BLOQUEADO' if not ok else 'AUDITADO'
            print(f'  [{status}] {pkt["node_id"]} | {pkt["direction"]} | {pkt["altered_fields"] or "nenhum"}')
        r=self.audit.get_status()
        chain='VERIFICADO' if r['integrity_verified'] else 'VIOLADO'
        print(f'  Auditoria: {r["audit_entries"]} entradas | Cadeia: {chain}')
    async def run_biolink_sync_demo(self):
        print('='*70)
        print('  BIO-LINK MASS SYNCHRONIZATION - 40Hz')
        print('='*70)
        for pulse in range(5):
            result=await self.biolink.emit_pulse()
            total=result['aligned']+result['drifting']+result['lost']
            pct=100*result['aligned']/total if total>0 else 0
            bar_len=int(pct/5)
            bar='='*bar_len+'-'*(20-bar_len)
            print(f'  Pulso {pulse+1:02d}: [{bar}] {pct:.1f}% | gc={result["global_coherence"]:.3f}')
            await asyncio.sleep(0.05)
        r=self.biolink.get_sync_report()
        print(f'  Sincronizados: {r["total_residents"]} | gc={r["global_coherence"]:.4f} | Pulsos={r["pulses_emitted"]}')
    async def run_temporal_lens_demo(self):
        print('='*70)
        print('  LENTE TEMPORAL - Projecao Rio 2027')
        print('='*70)
        proj=self.happiness.simulate_year(years=1)
        final=proj[-1]
        print(f'  {"Setor":<12}|{"2026":>8}|{"2027":>8}|{"Cresc":>8}')
        print('  ' + '-'*12 + '-+-' + '-'*8 + '-+-' + '-'*8 + '-+-' + '-'*8)
        for i,sec in enumerate(HAPPINESS_SECTORS):
            v26=self.happiness.governance_vector[i]
            v27=final[i]
            g=100*(v27-v26)/v26
            print(f'  {sec:<12}|{v26:>7.4f}|{v27:>7.4f}|{g:>+7.2f}%')
        ev_str=','.join([f'{e:.4f}' for e in self.happiness.eigenvalues[:3]])
        print(f'  Raio espectral: {self.happiness.spectral_radius:.6f} | Autovalores: [{ev_str}]')
        for i in range(5):
            direction=TemporalDirection.RETROCAUSAL if i%2==0 else TemporalDirection.CAUSAL
            pkt=self.arq.create_packet(np.random.randn(32),direction)
            result=await self.arq.transmit(pkt)
            print(f'  Packet {i+1:02d}: {result["direction"]:>12} | lat={result["latency_ms"]:>+7.2f}ms')
    async def run_full_demo(self):
        await self.init()
        await self.deploy()
        await self.run_temporal_lens_demo()
        await self.run_attack_simulation()
        await self.run_temporal_audit_demo()
        await self.run_biolink_sync_demo()
        print('='*70)
        print('  CORVOS v2.1-Sigma OPERACIONAL')
        print('  Todos os modulos integrados e validados')
        print('='*70)

async def main():
    c=CorvOSv2()
    await c.run_full_demo()

if __name__=='__main__':
    asyncio.run(main())