📘 Guida Completa JSON

{
  "studente": {
    "nome": "Mario",
    "cognome": "Rossi",
    "eta": 20,
    "matricola": "12345",
    "iscritto": true,
    "corso": "Informatica",
    "media_voti": 27.5,
    "esami_sostenuti": [
      {
        "materia": "Programmazione",
        "voto": 30,
        "lode": true,
        "data": "2024-01-15"
      },
      {
        "materia": "Basi di Dati",
        "voto": 28,
        "lode": false,
        "data": "2024-02-10"
      },
      {
        "materia": "Reti di Calcolatori",
        "voto": 25,
        "lode": false,
        "data": "2024-03-05"
      }
    ],
    "contatti": {
      "email": "mario.rossi@university.it",
      "telefono": "+39 123 456 7890",
      "indirizzo": {
        "via": "Via Roma",
        "numero": 10,
        "citta": "Milano",
        "cap": "20100"
      }
    },
    "note": null
  }
}

// Oggetto semplice
{
  "nome": "Giovanni",
  "eta": 25
}

// Oggetto con tipi diversi
{
  "prodotto": "Laptop",
  "prezzo": 899.99,
  "disponibile": true,
  "quantita": 15,
  "descrizione": "Laptop ad alte prestazioni",
  "note": null
}

// Oggetti annidati (nested objects)
{
  "azienda": {
    "nome": "TechCorp",
    "fondazione": 2010,
    "sede": {
      "citta": "Milano",
      "indirizzo": "Via Innovazione 42",
      "coordinate": {
        "latitudine": 45.4642,
        "longitudine": 9.1900
      }
    },
    "dipendenti": 250
  }
}

// Oggetto con array
{
  "biblioteca": {
    "nome": "Biblioteca Comunale",
    "libri": [
      {
        "titolo": "Il Nome della Rosa",
        "autore": "Umberto Eco",
        "isbn": "978-8845292620",
        "anno": 1980
      },
      {
        "titolo": "Se questo è un uomo",
        "autore": "Primo Levi",
        "isbn": "978-8806211875",
        "anno": 1947
      }
    ]
  }
}

// Array di numeri
[1, 2, 3, 4, 5]

// Array di stringhe
["rosso", "verde", "blu", "giallo"]

// Array di oggetti (molto comune nelle API)
[
  {
    "id": 1,
    "nome": "Alice",
    "ruolo": "Developer"
  },
  {
    "id": 2,
    "nome": "Bob",
    "ruolo": "Designer"
  },
  {
    "id": 3,
    "nome": "Charlie",
    "ruolo": "Manager"
  }
]

// Array misto (possibile ma sconsigliato)
[
  42,
  "testo",
  true,
  null,
  {"chiave": "valore"},
  [1, 2, 3]
]

// Array multidimensionale (matrice)
[
  [1, 2, 3],
  [4, 5, 6],
  [7, 8, 9]
]

// Caso d'uso reale: lista transazioni
{
  "transazioni": [
    {
      "id": "TRX001",
      "data": "2024-11-05",
      "importo": 150.50,
      "tipo": "entrata",
      "descrizione": "Vendita prodotto A"
    },
    {
      "id": "TRX002",
      "data": "2024-11-04",
      "importo": 75.00,
      "tipo": "uscita",
      "descrizione": "Acquisto materiali"
    }
  ]
}

// ❌ ERRORE: virgola finale
{
  "nome": "Mario",
  "eta": 30,  // <- virgola di troppo
}

// ❌ ERRORE: virgolette singole
{
  'nome': 'Mario'  // deve essere "nome": "Mario"
}

// ❌ ERRORE: chiavi senza virgolette
{
  nome: "Mario"  // deve essere "nome": "Mario"
}

// ❌ ERRORE: commenti (JSON non li supporta!)
{
  "nome": "Mario",  // questo è Mario
  "eta": 30
}

// ❌ ERRORE: valori undefined
{
  "nome": "Mario",
  "cognome": undefined  // deve essere null
}

// ❌ ERRORE: funzioni (non supportate)
{
  "calcola": function() { return 42; }
}

// ✅ CORRETTO
{
  "nome": "Mario",
  "eta": 30,
  "cognome": null,
  "attivo": true
}

{
  // Stringhe semplici
  "testo_semplice": "Ciao mondo!",
  "percorso": "/usr/local/bin",
  
  // Stringhe con caratteri speciali escape
  "con_virgolette": "Ha detto: \"Ciao!\"",
  "backslash": "C:\\Users\\Documents",
  "nuova_riga": "Prima riga\nSeconda riga",
  "tab": "Nome\tCognome",
  "backspace": "Testo\bCancellato",
  "form_feed": "Pagina\fNuova",
  "carriage_return": "Ritorno\rCarrello",
  
  // Unicode
  "unicode": "Stella: \u2605",
  "emoji": "Cuore: \u2764\uFE0F",
  "caratteri_speciali": "àèéìòù çñ ßø",
  
  // Stringhe multilingua
  "italiano": "Buongiorno",
  "inglese": "Good morning",
  "giapponese": "おはよう",
  "arabo": "صباح الخير",
  "russo": "Доброе утро",
  
  // Stringa vuota (valida)
  "stringa_vuota": "",
  
  // Stringhe lunghe
  "descrizione_lunga": "Questo è un esempio di stringa molto lunga che può contenere molte informazioni dettagliate su un argomento specifico senza limiti di lunghezza."
}

{
  // Interi
  "intero_positivo": 42,
  "intero_negativo": -17,
  "zero": 0,
  
  // Decimali (floating point)
  "decimale": 3.14159,
  "prezzo": 19.99,
  "percentuale": 0.75,
  
  // Notazione scientifica
  "molto_grande": 1.23e10,      // 12,300,000,000
  "molto_piccolo": 1.23e-10,    // 0.000000000123
  "equivalente": 6.022e23,      // Numero di Avogadro
  
  // Negativi con decimale
  "temperatura": -273.15,
  "debito": -1000.50,
  
  // Casi limite
  "numero_grande": 9007199254740991,  // MAX_SAFE_INTEGER in JavaScript
  
  // ❌ NON VALIDI in JSON
  // "hex": 0xFF,              // no esadecimale
  // "ottale": 0o77,           // no ottale
  // "binario": 0b1010,        // no binario
  // "infinito": Infinity,     // no infinito
  // "not_a_number": NaN,      // no NaN
  // "leading_zero": 007       // no zeri iniziali
}

{
  "attivo": true,
  "verificato": false,
  "premium": true,
  "accetta_newsletter": false,
  
  // Uso in condizioni
  "utente": {
    "nome": "Marco",
    "admin": false,
    "logged_in": true,
    "email_verified": true
  },
  
  // ❌ NON VALIDI
  // "errore1": True,     // deve essere tutto minuscolo
  // "errore2": "true",   // non deve essere stringa
  // "errore3": 1,        // non usare 1/0 per bool
  // "errore4": yes       // non esistono yes/no
}

{
  // Null per campi opzionali non valorizzati
  "secondo_nome": null,
  "data_fine_contratto": null,
  "foto_profilo": null,
  
  // Differenza tra null e altri valori
  "esempi": {
    "valore_null": null,           // assenza di valore
    "stringa_vuota": "",           // stringa presente ma vuota
    "numero_zero": 0,              // numero valido
    "false_booleano": false,       // boolean esplicito
    "array_vuoto": [],             // array valido senza elementi
    "oggetto_vuoto": {}            // oggetto valido senza proprietà
  },
  
  // Uso semantico di null
  "utente_eliminato": {
    "id": 123,
    "nome": "Account Eliminato",
    "email": null,                 // email rimossa
    "ultimo_accesso": null,        // mai più accessibile
    "note": null
  }
}

// 1. Virgola finale (trailing comma)
{
  "nome": "Mario",
  "eta": 30,  // ❌ virgola di troppo
}

// 2. Virgolette singole invece di doppie
{
  'nome': 'Mario'  // ❌ usa "
}

// 3. Chiavi senza virgolette
{
  nome: "Mario"  // ❌ la chiave deve essere "nome"
}

// 4. Commenti (non supportati in JSON standard)
{
  "nome": "Mario",  // ❌ questo commento causa errore
  "eta": 30
}

// 5. Virgola mancante tra elementi
{
  "nome": "Mario"   // ❌ manca virgola
  "eta": 30
}

// 6. Valori booleani in maiuscolo
{
  "attivo": True  // ❌ deve essere true
}

// 7. Numeri con zeri iniziali
{
  "codice": 007  // ❌ deve essere 7 o "007"
}

// 8. Virgolette non chiuse
{
  "nome": "Mario  // ❌ manca "
}

// 9. Escape scorretto
{
  "path": "C:\Users\Mario"  // ❌ deve essere "C:\\Users\\Mario"
}

// 10. Caratteri speciali non escaped
{
  "citazione": "Lui disse: "Ciao""  // ❌ deve essere \"Ciao\"
}

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "title": "Studente",
  "description": "Schema per validare i dati di uno studente",
  "type": "object",
  "properties": {
    "nome": {
      "type": "string",
      "minLength": 2,
      "maxLength": 50,
      "pattern": "^[A-Za-zÀ-ÿ ]+$",
      "description": "Nome dello studente (solo lettere)"
    },
    "cognome": {
      "type": "string",
      "minLength": 2,
      "maxLength": 50
    },
    "eta": {
      "type": "integer",
      "minimum": 16,
      "maximum": 99,
      "description": "Età dello studente"
    },
    "email": {
      "type": "string",
      "format": "email",
      "description": "Email istituzionale"
    },
    "matricola": {
      "type": "string",
      "pattern": "^[0-9]{6}$",
      "description": "Matricola a 6 cifre"
    },
    "corso": {
      "type": "string",
      "enum": ["Informatica", "Ingegneria", "Matematica", "Fisica"],
      "description": "Corso di laurea"
    },
    "media_voti": {
      "type": "number",
      "minimum": 18,
      "maximum": 30,
      "description": "Media ponderata"
    },
    "esami_sostenuti": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "materia": {"type": "string"},
          "voto": {
            "type": "integer",
            "minimum": 18,
            "maximum": 30
          },
          "lode": {"type": "boolean"},
          "data": {
            "type": "string",
            "format": "date"
          }
        },
        "required": ["materia", "voto", "data"]
      },
      "minItems": 0,
      "maxItems": 50
    }
  },
  "required": ["nome", "cognome", "matricola", "email"],
  "additionalProperties": false
}

import json

# Dizionario Python
studente = {
    "nome": "Alice",
    "cognome": "Bianchi",
    "eta": 22,
    "matricola": "123456",
    "attivo": True,
    "voti": [28, 30, 27, 29],
    "indirizzo": {
        "via": "Via Roma",
        "citta": "Milano"
    },
    "note": None
}

# Conversione a stringa JSON
json_string = json.dumps(studente)
print(json_string)
# Output: {"nome": "Alice", "cognome": "Bianchi", ...}

# Con indentazione per leggibilità
json_formattato = json.dumps(studente, indent=4)
print(json_formattato)
# Output:
# {
#     "nome": "Alice",
#     "cognome": "Bianchi",
#     ...
# }

# Con ordinamento chiavi alfabetico
json_ordinato = json.dumps(studente, indent=4, sort_keys=True)

# Rimuovere spazi per compattezza
json_compatto = json.dumps(studente, separators=(',', ':'))
print(json_compatto)
# Output: {"nome":"Alice","cognome":"Bianchi",...}

import json

# Stringa JSON
json_data = '''
{
    "nome": "Bob",
    "eta": 25,
    "skills": ["Python", "JavaScript", "SQL"],
    "esperienza": {
        "anni": 3,
        "aziende": ["TechCorp", "StartupX"]
    },
    "certificazioni": null
}
'''

# Parsing JSON -> Python dict
persona = json.loads(json_data)

# Accesso ai dati
print(persona["nome"])              # "Bob"
print(persona["eta"])               # 25
print(persona["skills"][0])         # "Python"
print(persona["esperienza"]["anni"]) # 3

# Verifica tipo
print(type(persona))                # 
print(type(persona["skills"]))      # 
print(type(persona["certificazioni"])) # 

# Iterazione
for skill in persona["skills"]:
    print(f"- {skill}")

# Gestione errori
try:
    dati_invalidi = '{"nome": "Test"'  # JSON malformato
    json.loads(dati_invalidi)
except json.JSONDecodeError as e:
    print(f"Errore parsing JSON: {e}")
    print(f"Posizione errore: linea {e.lineno}, colonna {e.colno}")

import json
from datetime import datetime, date
from decimal import Decimal

class CustomEncoder(json.JSONEncoder):
    """Encoder personalizzato per tipi Python non standard"""
    
    def default(self, obj):
        # Gestione datetime
        if isinstance(obj, datetime):
            return {
                "_type": "datetime",
                "value": obj.isoformat()
            }
        
        # Gestione date
        if isinstance(obj, date):
            return {
                "_type": "date",
                "value": obj.isoformat()
            }
        
        # Gestione Decimal
        if isinstance(obj, Decimal):
            return {
                "_type": "decimal",
                "value": str(obj)
            }
        
        # Gestione set
        if isinstance(obj, set):
            return {
                "_type": "set",
                "value": list(obj)
            }
        
        # Gestione bytes
        if isinstance(obj, bytes):
            import base64
            return {
                "_type": "bytes",
                "value": base64.b64encode(obj).decode('utf-8')
            }
        
        # Se non gestito, usa comportamento default
        return super().default(obj)

def custom_decoder(dct):
    """Decoder personalizzato per ricostruire oggetti Python"""
    
    if "_type" not in dct:
        return dct
    
    tipo = dct["_type"]
    valore = dct["value"]
    
    if tipo == "datetime":
        return datetime.fromisoformat(valore)
    elif tipo == "date":
        return date.fromisoformat(valore)
    elif tipo == "decimal":
        return Decimal(valore)
    elif tipo == "set":
        return set(valore)
    elif tipo == "bytes":
        import base64
        return base64.b64decode(valore)
    
    return dct

# Esempio utilizzo
dati = {
    "evento": "Conferenza",
    "data": datetime.now(),
    "partecipanti": {"Alice", "Bob", "Charlie"},
    "budget": Decimal("1500.50"),
    "immagine": b"dati binari esempio"
}

# Serializzazione con encoder custom
json_string = json.dumps(dati, cls=CustomEncoder, indent=2)
print(json_string)

# Deserializzazione con decoder custom
dati_ripristinati = json.loads(json_string, object_hook=custom_decoder)
print(type(dati_ripristinati["data"]))  # 
print(type(dati_ripristinati["partecipanti"]))  # 

import json
from pathlib import Path

# Metodo 1: Lettura base
with open('studenti.json', 'r', encoding='utf-8') as file:
    studenti = json.load(file)
    print(studenti)

# Metodo 2: Con gestione errori completa
def leggi_json(percorso_file):
    """Legge file JSON con gestione errori robusta"""
    try:
        # Verifica esistenza file
        if not Path(percorso_file).exists():
            print(f"File {percorso_file} non trovato")
            return None
        
        # Lettura file
        with open(percorso_file, 'r', encoding='utf-8') as f:
            dati = json.load(f)
            return dati
            
    except json.JSONDecodeError as e:
        print(f"Errore parsing JSON: {e}")
        print(f"Riga {e.lineno}, colonna {e.colno}")
        return None
    except PermissionError:
        print(f"Permessi insufficienti per leggere {percorso_file}")
        return None
    except Exception as e:
        print(f"Errore inaspettato: {e}")
        return None

# Utilizzo
dati = leggi_json('configurazione.json')
if dati:
    print(f"Configurazione caricata con {len(dati)} elementi")

# Metodo 3: Lettura con valori predefiniti
def leggi_con_default(percorso, default=None):
    """Legge JSON, ritorna default se errore"""
    try:
        with open(percorso, 'r', encoding='utf-8') as f:
            return json.load(f)
    except:
        return default if default is not None else {}

config = leggi_con_default('config.json', {"debug": False, "timeout": 30})

import json
from pathlib import Path

# Dati da salvare
database = {
    "studenti": [
        {"id": 1, "nome": "Alice", "voto": 28},
        {"id": 2, "nome": "Bob", "voto": 30},
        {"id": 3, "nome": "Charlie", "voto": 25}
    ],
    "corso": "Python Avanzato",
    "anno": 2024
}

# Metodo 1: Scrittura base
with open('database.json', 'w', encoding='utf-8') as file:
    json.dump(database, file, indent=4, ensure_ascii=False)

# Metodo 2: Funzione salvataggio sicuro
def salva_json(dati, percorso_file, indent=4):
    """Salva dati in JSON con backup e verifica"""
    percorso = Path(percorso_file)
    
    # Crea backup se file esiste
    if percorso.exists():
        backup = percorso.with_suffix('.json.backup')
        percorso.rename(backup)
        print(f"Backup creato: {backup}")
    
    try:
        # Scrittura file temporaneo
        temp = percorso.with_suffix('.tmp')
        with open(temp, 'w', encoding='utf-8') as f:
            json.dump(dati, f, indent=indent, ensure_ascii=False, sort_keys=True)
        
        # Verifica validità
        with open(temp, 'r') as f:
            json.load(f)  # Test parsing
        
        # Rinomina temporaneo in definitivo
        temp.rename(percorso)
        print(f"File salvato: {percorso}")
        
        # Rimuovi backup se tutto ok
        if percorso.with_suffix('.json.backup').exists():
            percorso.with_suffix('.json.backup').unlink()
        
        return True
        
    except Exception as e:
        print(f"Errore salvataggio: {e}")
        # Ripristina backup
        if percorso.with_suffix('.json.backup').exists():
            percorso.with_suffix('.json.backup').rename(percorso)
        return False

# Utilizzo
successo = salva_json(database, 'archivio_studenti.json')

# Metodo 3: Append a file JSON (array)
def aggiungi_a_json_array(nuovo_elemento, percorso_file):
    """Aggiunge elemento a array JSON esistente"""
    # Leggi dati esistenti
    if Path(percorso_file).exists():
        with open(percorso_file, 'r') as f:
            dati = json.load(f)
    else:
        dati = []
    
    # Aggiungi nuovo elemento
    dati.append(nuovo_elemento)
    
    # Salva
    with open(percorso_file, 'w', encoding='utf-8') as f:
        json.dump(dati, f, indent=4)

# Esempio
aggiungi_a_json_array(
    {"id": 4, "nome": "Diana", "voto": 29},
    'studenti_lista.json'
)

import ijson  # pip install ijson

# Esempio: File JSON enorme con array di oggetti
# {
#   "utenti": [
#     {"id": 1, "nome": "Alice", ...},
#     {"id": 2, "nome": "Bob", ...},
#     ...milioni di elementi...
#   ]
# }

def processa_json_streaming(percorso_file):
    """Processa file JSON enorme senza caricarlo tutto in memoria"""
    
    with open(percorso_file, 'rb') as file:
        # Parser incrementale
        parser = ijson.items(file, 'utenti.item')
        
        count = 0
        for utente in parser:
            # Processa ogni utente uno alla volta
            if utente.get('eta', 0) > 25:
                print(f"Utente: {utente['nome']}")
                count += 1
            
            # Limita output per esempio
            if count >= 10:
                break

# Lettura selettiva di campi specifici
def estrai_campo_specifico(percorso_file, campo):
    """Estrae solo un campo specifico dal JSON"""
    
    with open(percorso_file, 'rb') as file:
        # Cerca pattern specifico
        parser = ijson.items(file, f'dati.{campo}')
        
        for valore in parser:
            yield valore  # Generator per efficienza memoria

# Esempio
for valore in estrai_campo_specifico('big_data.json', 'prezzi.item'):
    print(valore)

import json
import orjson  # pip install orjson
import ujson   # pip install ujson
import time

# Dati di test
dati_grandi = {
    "utenti": [
        {"id": i, "nome": f"Utente{i}", "voti": list(range(20))}
        for i in range(10000)
    ]
}

# Benchmark serializzazione
def benchmark_serializzazione():
    # json standard
    start = time.time()
    _ = json.dumps(dati_grandi)
    tempo_json = time.time() - start
    
    # orjson (il più veloce)
    start = time.time()
    _ = orjson.dumps(dati_grandi)
    tempo_orjson = time.time() - start
    
    # ujson
    start = time.time()
    _ = ujson.dumps(dati_grandi)
    tempo_ujson = time.time() - start
    
    print(f"json:   {tempo_json:.4f}s")
    print(f"orjson: {tempo_orjson:.4f}s (speedup: {tempo_json/tempo_orjson:.2f}x)")
    print(f"ujson:  {tempo_ujson:.4f}s (speedup: {tempo_json/tempo_ujson:.2f}x)")

# orjson - Uso avanzato
import orjson

# Serializzazione con opzioni
json_bytes = orjson.dumps(
    dati_grandi,
    option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS
)

# orjson restituisce bytes, non str
json_str = json_bytes.decode('utf-8')

# Deserializzazione ultrarapida
dati = orjson.loads(json_bytes)

import requests
import json

# GET request - Ottenere dati
response = requests.get('https://api.example.com/users/123')
if response.status_code == 200:
    utente = response.json()  # Automatic JSON decoding
    print(utente['nome'])

# POST request - Inviare dati JSON
nuovo_utente = {
    "nome": "Mario",
    "email": "mario@example.com",
    "ruolo": "admin"
}

response = requests.post(
    'https://api.example.com/users',
    json=nuovo_utente,  # Automatic JSON encoding
    headers={'Authorization': 'Bearer TOKEN'}
)

if response.status_code == 201:
    print("Utente creato:", response.json()['id'])

# PUT request - Aggiornare dati
aggiornamento = {"ruolo": "super_admin"}
response = requests.put(
    'https://api.example.com/users/123',
    json=aggiornamento
)

# DELETE request
response = requests.delete('https://api.example.com/users/123')

# Gestione errori completa
def chiamata_api_sicura(url, metodo='GET', dati=None):
    """Wrapper per chiamate API con gestione errori"""
    try:
        if metodo == 'GET':
            response = requests.get(url, timeout=10)
        elif metodo == 'POST':
            response = requests.post(url, json=dati, timeout=10)
        
        response.raise_for_status()  # Solleva eccezione per status 4xx/5xx
        return response.json()
        
    except requests.exceptions.ConnectionError:
        print("Errore connessione")
    except requests.exceptions.Timeout:
        print("Timeout richiesta")
    except requests.exceptions.HTTPError as e:
        print(f"Errore HTTP: {e.response.status_code}")
    except json.JSONDecodeError:
        print("Risposta non è JSON valido")
    
    return None

import json
import uuid
from datetime import datetime
from typing import Dict, List, Any, Optional
from pathlib import Path

class JSONDatabase:
    """Database NoSQL che usa JSON per lo storage"""
    
    def __init__(self, db_path: str = "database.json"):
        self.db_path = Path(db_path)
        self.data = self._initialize_db()
        self.transaction_log = []
    
    def _initialize_db(self) -> Dict:
        """Inizializza o carica database"""
        if self.db_path.exists():
            with open(self.db_path, 'r', encoding='utf-8') as f:
                return json.load(f)
        
        # Struttura database vuoto
        return {
            "metadata": {
                "created": datetime.now().isoformat(),
                "version": "1.0"
            },
            "collections": {}
        }
    
    def save(self):
        """Salva database su disco"""
        self.data["metadata"]["last_modified"] = datetime.now().isoformat()
        
        with open(self.db_path, 'w', encoding='utf-8') as f:
            json.dump(self.data, f, indent=2, ensure_ascii=False)
    
    def create_collection(self, name: str) -> bool:
        """Crea nuova collezione"""
        if name in self.data["collections"]:
            print(f"⚠️  Collezione '{name}' già esistente")
            return False
        
        self.data["collections"][name] = {
            "documents": {},
            "metadata": {
                "created": datetime.now().isoformat(),
                "count": 0
            }
        }
        self.save()
        print(f"✓ Collezione '{name}' creata")
        return True
    
    def drop_collection(self, name: str) -> bool:
        """Elimina collezione"""
        if name not in self.data["collections"]:
            print(f"❌ Collezione '{name}' non trovata")
            return False
        
        del self.data["collections"][name]
        self.save()
        print(f"✓ Collezione '{name}' eliminata")
        return True
    
    def insert(self, collection: str, document: Dict) -> Optional[str]:
        """Inserisce documento in collezione"""
        if collection not in self.data["collections"]:
            self.create_collection(collection)
        
        # Genera ID univoco
        doc_id = str(uuid.uuid4())
        
        # Aggiungi metadata
        document["_id"] = doc_id
        document["_created_at"] = datetime.now().isoformat()
        document["_updated_at"] = datetime.now().isoformat()
        
        # Salva documento
        self.data["collections"][collection]["documents"][doc_id] = document
        self.data["collections"][collection]["metadata"]["count"] += 1
        
        self.save()
        self._log_transaction("INSERT", collection, doc_id)
        
        return doc_id
    
    def find(self, collection: str, query: Dict = None) -> List[Dict]:
        """Trova documenti che matchano query"""
        if collection not in self.data["collections"]:
            return []
        
        documents = self.data["collections"][collection]["documents"].values()
        
        if query is None:
            return list(documents)
        
        # Filtra documenti
        risultati = []
        for doc in documents:
            if self._match_query(doc, query):
                risultati.append(doc)
        
        return risultati
    
    def find_one(self, collection: str, query: Dict) -> Optional[Dict]:
        """Trova primo documento che matcha query"""
        risultati = self.find(collection, query)
        return risultati[0] if risultati else None

    def update(self, collection: str, query: Dict, update: Dict) -> int:
        """Aggiorna documenti che matchano query"""
        if collection not in self.data["collections"]:
            return 0
        
        documenti = self.find(collection, query)
        count = 0
        
        for doc in documenti:
            doc_id = doc["_id"]
            
            # Applica update
            for key, value in update.items():
                doc[key] = value
            
            doc["_updated_at"] = datetime.now().isoformat()
            
            # Salva modifiche
            self.data["collections"][collection]["documents"][doc_id] = doc
            self._log_transaction("UPDATE", collection, doc_id)
            count += 1
        
        if count > 0:
            self.save()
        
        return count
    
    def delete(self, collection: str, query: Dict) -> int:
        """Elimina documenti che matchano query"""
        if collection not in self.data["collections"]:
            return 0
        
        documenti = self.find(collection, query)
        count = 0
        
        for doc in documenti:
            doc_id = doc["_id"]
            del self.data["collections"][collection]["documents"][doc_id]
            self.data["collections"][collection]["metadata"]["count"] -= 1
            self._log_transaction("DELETE", collection, doc_id)
            count += 1
        
        if count > 0:
            self.save()
        
        return count
    
    def _match_query(self, document: Dict, query: Dict) -> bool:
        """Verifica se documento corrisponde a query"""
        for key, value in query.items():
            if key not in document:
                return False
            
            # Supporto operatori
            if isinstance(value, dict):
                doc_value = document[key]
                
                if "$gt" in value and not doc_value > value["$gt"]:
                    return False
                if "$lt" in value and not doc_value < value["$lt"]:
                    return False
                if "$gte" in value and not doc_value >= value["$gte"]:
                    return False
                if "$lte" in value and not doc_value <= value["$lte"]:
                    return False
                if "$ne" in value and doc_value == value["$ne"]:
                    return False
                if "$in" in value and doc_value not in value["$in"]:
                    return False
            else:
                if document[key] != value:
                    return False
        
        return True
    
    def aggregate(self, collection: str, pipeline: List[Dict]) -> List[Any]:
        """Aggregazione semplificata"""
        documents = self.find(collection)
        
        for stage in pipeline:
            if "$match" in stage:
                documents = [d for d in documents if self._match_query(d, stage["$match"])]
            elif "$sort" in stage:
                field = list(stage["$sort"].keys())[0]
                reverse = stage["$sort"][field] == -1
                documents.sort(key=lambda x: x.get(field), reverse=reverse)
            elif "$limit" in stage:
                documents = documents[:stage["$limit"]]
            elif "$project" in stage:
                projected = []
                for doc in documents:
                    new_doc = {}
                    for field, include in stage["$project"].items():
                        if include and field in doc:
                            new_doc[field] = doc[field]
                    projected.append(new_doc)
                documents = projected
        
        return documents
    
    def backup(self, backup_path: str = None):
        """Crea backup del database"""
        backup_path = backup_path or f"backup_{datetime.now():%Y%m%d_%H%M%S}.json"
        
        with open(backup_path, 'w', encoding='utf-8') as f:
            json.dump({
                "data": self.data,
                "metadata": {
                    "backup_date": datetime.now().isoformat(),
                    "transaction_count": len(self.transaction_log),
                    "collections": list(self.data["collections"].keys())
                }
            }, f, indent=2, ensure_ascii=False)
        
        return backup_path
    
    def stats(self) -> Dict:
        """Statistiche database"""
        stats = {
            "collections": {},
            "total_documents": 0,
            "total_size_bytes": len(json.dumps(self.data).encode('utf-8'))
        }
        
        for name, collection in self.data["collections"].items():
            doc_count = collection["metadata"]["count"]
            stats["collections"][name] = {
                "count": doc_count,
                "created": collection["metadata"]["created"]
            }
            stats["total_documents"] += doc_count
        
        return stats
    
    def _log_transaction(self, operation: str, collection: str, doc_id: str):
        """Log transazione per audit"""
        self.transaction_log.append({
            "timestamp": datetime.now().isoformat(),
            "operation": operation,
            "collection": collection,
            "document_id": doc_id
        })

# ========================================
# ESEMPIO DI UTILIZZO COMPLETO
# ========================================

db = JSONDatabase("test_db.json")

# Crea collezione
db.create_collection("users")

# Inserisci documenti
user1_id = db.insert("users", {
    "name": "Alice",
    "email": "alice@example.com",
    "age": 30,
    "active": True
})

user2_id = db.insert("users", {
    "name": "Bob",
    "email": "bob@example.com",
    "age": 25,
    "active": True
})

user3_id = db.insert("users", {
    "name": "Charlie",
    "email": "charlie@example.com",
    "age": 35,
    "active": False
})

print("\n📝 Documenti inseriti\n")

# Query
print("👥 Tutti gli utenti:")
all_users = db.find("users")
for user in all_users:
    print(f"  - {user['name']} ({user['email']})")

print("\n🔍 Utenti attivi con età > 26:")
active_users = db.find("users", {
    "active": True,
    "age": {"$gt": 26}
})
for user in active_users:
    print(f"  - {user['name']}, età: {user['age']}")

# Aggregazione
print("\n📊 Utenti ordinati per età (desc), limitati a 2:")
result = db.aggregate("users", [
    {"$match": {"active": True}},
    {"$sort": {"age": -1}},
    {"$limit": 2},
    {"$project": {"name": 1, "age": 1}}
])
print(json.dumps(result, indent=2))

# Statistiche
print("\n📈 Statistiche database:")
print(json.dumps(db.stats(), indent=2))

# Backup
backup_file = db.backup()
print(f"\n💾 Backup creato: {backup_file}")