// Blocchi: gruppi di neuroni nuovi aggiunti alla rete (neurogenesi).
//
// 1. L'utente crea un blocco scegliendo solo quanti neuroni vuole: nasce vuoto, senza funzione.
// 2. L'utente gli assegna una funzione a parole. Neuronal la applica da solo:
//    scrive esempi della funzione, li confronta con testi neutri per capire in quali strati vive,
//    costruisce i neuroni (rilevano la funzione nell'ingresso FFN, la rinforzano nell'uscita),
//    li collega alle sinapsi della rete e prova il blocco a diverse intensità scegliendo la migliore.
// 3. Il blocco viene salvato e ricaricato a ogni avvio; Neuronal sa di averlo e a cosa serve.
#pragma once
#include <stdbool.h>

#include "atlas.h"
#include "brain.h"
#include "sbuf.h"
#include "synapse.h"

#define BLOCK_MAX_NEURONS  512
#define BLOCK_MAX_EXAMPLES 16
#define BLOCK_LINKS        3     // sinapsi in ingresso e in uscita memorizzate per neurone

typedef struct {
    int   id;
    int   region;             // 0 = blocco creato; >0 = nuova funzione della macroarea con questo id
    char  name[64];
    char  function[300];
    int   n;                  // neuroni
    bool  applied;            // ha ricevuto una funzione
    bool  enabled;
    float gain;
    int   first, last;        // strati a cui è collegato
    float separation;         // quanto il blocco distingue la sua funzione dai testi neutri
    float pos_rate, neg_rate; // attivazione media sugli esempi e sui testi neutri
    char  effect[600];        // la prova fatta da Neuronal
    int   n_examples;
    char *examples[BLOCK_MAX_EXAMPLES];
    int   n_embd;             // lunghezza dei vettori di peso
    BrainArea area;           // pesi dei neuroni (se applied)
    SynLink *links_out;       // [n][BLOCK_LINKS]
    SynLink *links_in;        // [n][BLOCK_LINKS]
    // autodiagnosi (solo in memoria, ricalcolata a ogni avvio)
    bool  auto_off;           // sospeso da Neuronal
    float auto_gain;          // > 0: intensità ridotta da Neuronal
    bool  forced;             // l'utente ha chiesto di non toccarlo
    char  auto_reason[200];
} Block;

typedef void (*block_progress_fn)(void *ud, const char *msg);

void block_init(Block *b, int id, int n, const char *name);
void block_free(Block *b);

// Applica una funzione al blocco. user_examples opzionali. fix_first/fix_last: se >= 0 il blocco
// viene costruito solo dentro quegli strati (riconversione di una macroarea), altrimenti li sceglie Neuronal.
// Ritorna false con err compilato.
bool block_apply(Block *blk, Brain *brain, Synapses *syn, const Atlas *atlas, const char *system_prompt,
                 const char *function, char **user_examples, int n_user_examples, int fix_first, int fix_last,
                 block_progress_fn progress, void *ud, char *err, size_t err_cap);

bool block_save(const Block *b, const char *dir);
int  block_load_all(const char *dir, int n_embd, Block **out);   // ritorna quanti
// Vero se il file del blocco è leggibile e integro.
bool block_file_ok(const char *path, int n_embd);
void block_delete_file(const char *dir, int id);

// JSON per la pagina. links: include le sinapsi di ogni neurone.
void block_json(const Block *b, SBuf *out, bool links);