Rust — Conceitos Básicos para Smart Contracts: Tutorial Completo para Iniciantes

fn main() {
    println!("Olá, Rust!");
}

fn main() {
    let x = 10;        // imutável
    // x = 20;         // ❌ ERRO: cannot assign twice to immutable variable

    let mut y = 10;    // mutável (precisa de `mut`)
    y = 20;            // ✅ OK
    println!("y = {}", y);
}

fn main() {
    let valor = "42";           // &str
    let valor = valor.len();    // agora é usize — shadowing
    println!("Tamanho: {}", valor);
}

// Somente com &mut podemos modificar o estado da conta
let sensor = &mut ctx.accounts.sensor_account;
sensor.score = 0;       // ✅ permitido porque sensor é &mut
sensor.is_active = true;

fn main() {
    let penalty_level: u8 = 2;
    let score: u64 = 150_000;          // underscores para legibilidade
    let timestamp: i64 = 1_700_000_000;
    let calculo: u128 = 999_999_999_999;
    let tamanho: usize = 32;

    println!("Penalty: {}, Score: {}", penalty_level, score);
}

fn main() {
    // Booleano
    let is_active: bool = true;

    // String (heap-allocated, mutável, owned)
    let sensor_id: String = String::from("temp-001");

    // &str (referência a string, imutável)
    let tipo: &str = "temperature";

    println!("Sensor {} ({}) ativo: {}", sensor_id, tipo, is_active);
}

fn main() {
    let owned: String = "hello".to_string();  // String → owned
    let borrowed: &str = &owned;              // &str → emprestada
    let literal: &str = "world";              // &str → literal (estático)

    // Convertendo
    let s1: String = literal.to_string();
    let s2: String = String::from(literal);
    let bytes: &[u8] = literal.as_bytes();    // &str → &[u8]

    println!("{} {} {:?}", owned, literal, bytes);
}

pub struct SensorAccount {
    pub sensor_id: String,      // String porque a conta é dona do dado
    pub sensor_type: String,
}

/// Tamanho máximo do identificador do sensor
const MAX_SENSOR_ID_LEN: usize = 32;
/// Tamanho máximo da descrição do tipo de sensor
const MAX_SENSOR_TYPE_LEN: usize = 16;
/// Fator de escala para aritmética de ponto fixo
const SCALE: u64 = 1_000_000;
/// Base em basis points (100% = 10_000)
const BPS_BASE: u64 = 10_000;

fn main() {
    println!("Escala: {}, BPS: {}", SCALE, BPS_BASE);
}

/// Soma dois valores u64 e retorna o resultado.
fn somar(a: u64, b: u64) -> u64 {
    a + b   // sem ponto-e-vírgula = expressão de retorno
}

/// Função sem retorno (retorna implicitamente `()`)
fn imprimir_score(nome: &str, score: u64) {
    println!("Score de {}: {}", nome, score);
}

fn main() {
    let total = somar(100, 50);
    imprimir_score("temp-001", total);
}

fn validar_sensor_id(sensor_id: &str) -> Result<(), String> {
    if sensor_id.len() > 32 {
        Err("Identificador do sensor excede o tamanho máximo".to_string())
    } else if sensor_id.is_empty() {
        Err("Identificador não pode ser vazio".to_string())
    } else {
        Ok(())
    }
}

fn main() {
    match validar_sensor_id("temp-001") {
        Ok(()) => println!("Sensor válido!"),
        Err(msg) => println!("Erro: {}", msg),
    }
}

// Sem `pub` → privada ao módulo
fn funcao_interna() {}

// Com `pub` → acessível fora do módulo
pub fn funcao_publica() {}

pub fn register_sensor(
    ctx: Context<RegisterSensor>,
    sensor_id: String,
    sensor_type: String,
    latitude: i64,
    longitude: i64,
) -> Result<()> {
    // ... implementação
    Ok(())
}

struct SensorAccount {
    owner: String,
    sensor_id: String,
    sensor_type: String,
    latitude: i64,
    longitude: i64,
    score: u64,
    penalty_level: u8,
    is_active: bool,
    registered_at: i64,
}

fn main() {
    let sensor = SensorAccount {
        owner: "Alice".to_string(),
        sensor_id: "temp-001".to_string(),
        sensor_type: "temperature".to_string(),
        latitude: -38_516_700,
        longitude: -386_120_000,
        score: 0,
        penalty_level: 0,
        is_active: true,
        registered_at: 1_700_000_000,
    };

    println!("Sensor: {} ({})", sensor.sensor_id, sensor.sensor_type);
    println!("Localização: {}, {}", sensor.latitude, sensor.longitude);
    println!("Ativo: {}", sensor.is_active);
}

pub struct OracleAccount {
    pub authority: String,
    pub brl_usdc_rate: u64,
    pub token_price: u64,
    pub last_updated: i64,
    pub twap_observations: Vec<PriceObservation>,
    pub bump: u8,
}

struct Sensor {
    sensor_id: String,
    score: u64,
    penalty_level: u8,
    is_active: bool,
}

impl Sensor {
    /// Construtor (convenção: `new`)
    fn new(id: &str) -> Self {
        Sensor {
            sensor_id: id.to_string(),
            score: 0,
            penalty_level: 0,
            is_active: true,
        }
    }

    /// Método que recebe &self (leitura)
    fn esta_banido(&self) -> bool {
        self.penalty_level >= 3
    }

    /// Método que recebe &mut self (escrita)
    fn adicionar_score(&mut self, delta: u64) {
        if self.is_active && !self.esta_banido() {
            self.score += delta;
        }
    }

    /// Aplicar penalidade com slashing
    fn aplicar_penalidade(&mut self, nivel: u8, slash: u64) {
        self.penalty_level = nivel;
        self.score = self.score.saturating_sub(slash);
        if nivel >= 3 {
            self.is_active = false;
        }
    }
}

fn main() {
    let mut s = Sensor::new("temp-001");
    s.adicionar_score(100);
    println!("Score: {}", s.score);         // 100

    s.aplicar_penalidade(1, 30);
    println!("Score após penalidade: {}", s.score); // 70

    s.aplicar_penalidade(3, 0);
    println!("Banido: {}", s.esta_banido()); // true
    println!("Ativo: {}", s.is_active);      // false
}

enum StatusSensor {
    Ativo,
    Inativo,
    Banido,
}

fn descrever_status(status: &StatusSensor) -> &str {
    match status {
        StatusSensor::Ativo => "Operando normalmente",
        StatusSensor::Inativo => "Desativado temporariamente",
        StatusSensor::Banido => "Removido da rede permanentemente",
    }
}

fn main() {
    let status = StatusSensor::Ativo;
    println!("{}", descrever_status(&status));
}

enum Erro {
    SensorIdMuitoLongo,
    ScoreOverflow(u64),
    Personalizado(String),
}

fn descrever_erro(e: &Erro) -> String {
    match e {
        Erro::SensorIdMuitoLongo => "ID muito longo".to_string(),
        Erro::ScoreOverflow(valor) => format!("Overflow no score: {}", valor),
        Erro::Personalizado(msg) => msg.clone(),
    }
}

fn main() {
    let e = Erro::ScoreOverflow(999);
    println!("{}", descrever_erro(&e));
}

#[error_code]
pub enum RegistryError {
    #[msg("Identificador do sensor excede o tamanho máximo")]
    SensorIdTooLong,
    #[msg("Sensor está inativo")]
    SensorInactive,
    #[msg("Sensor está banido da rede")]
    SensorBanned,
    #[msg("Nível de penalidade inválido")]
    InvalidPenalty,
    #[msg("Overflow aritmético")]
    Overflow,
    #[msg("Acesso não autorizado")]
    Unauthorized,
}

// Result é definido assim na standard library:
// enum Result<T, E> {
//     Ok(T),
//     Err(E),
// }

fn dividir(a: u64, b: u64) -> Result<u64, String> {
    if b == 0 {
        Err("Divisão por zero".to_string())
    } else {
        Ok(a / b)
    }
}

fn main() {
    // Tratando com match
    match dividir(100, 3) {
        Ok(resultado) => println!("100 / 3 = {}", resultado),
        Err(msg) => println!("Erro: {}", msg),
    }

    // Tratando com unwrap (cuidado: panic se for Err)
    let r = dividir(100, 5).unwrap();
    println!("100 / 5 = {}", r);
}

fn calcular_tokens(receita: u64, preco: u64) -> Result<u64, String> {
    if preco == 0 {
        return Err("Preço não pode ser zero".to_string());
    }

    let elegivel = receita
        .checked_mul(950_000)
        .ok_or("Overflow na multiplicação".to_string())?;  // ← propaga se None

    let tokens = elegivel
        .checked_div(preco)
        .ok_or("Overflow na divisão".to_string())?;        // ← propaga se None

    Ok(tokens)
}

fn main() {
    match calcular_tokens(534_440_000, 500_000) {
        Ok(t) => println!("Tokens: {}", t),
        Err(e) => println!("Erro: {}", e),
    }
}

// Option é definido assim:
// enum Option<T> {
//     Some(T),
//     None,
// }

fn buscar_sensor(id: &str) -> Option<String> {
    match id {
        "temp-001" => Some("Sensor de Temperatura".to_string()),
        "umid-002" => Some("Sensor de Umidade".to_string()),
        _ => None,
    }
}

fn main() {
    // Tratando com match
    match buscar_sensor("temp-001") {
        Some(nome) => println!("Encontrado: {}", nome),
        None => println!("Sensor não encontrado"),
    }

    // Tratando com if let
    if let Some(nome) = buscar_sensor("xyz") {
        println!("Encontrado: {}", nome);
    } else {
        println!("Não encontrado");
    }

    // Convertendo Option para Result com ok_or
    let resultado: Result<String, &str> = buscar_sensor("xyz")
        .ok_or("Sensor não existe");
    println!("{:?}", resultado); // Err("Sensor não existe")
}

fn main() {
    let a: u64 = 100;
    let b: u64 = 50;

    // checked_add retorna Option<u64>
    // ok_or converte para Result<u64, &str>
    let soma = a.checked_add(b)
        .ok_or("Overflow aritmético");

    println!("{:?}", soma); // Ok(150)

    // Com valor que causaria overflow em u8
    let x: u8 = 250;
    let resultado = x.checked_add(10)
        .ok_or("Overflow aritmético");

    println!("{:?}", resultado); // Err("Overflow aritmético")
}

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;                     // s1 foi MOVIDO para s2
    // println!("{}", s1);           // ❌ ERRO: s1 não é mais válido
    println!("{}", s2);              // ✅ OK
}

fn imprimir_sensor(id: &String) {       // empréstimo imutável
    println!("Sensor: {}", id);
}

fn ativar_sensor(ativo: &mut bool) {    // empréstimo mutável
    *ativo = true;                      // desreferencia para modificar
}

fn main() {
    let sensor_id = String::from("temp-001");
    imprimir_sensor(&sensor_id);        // empresta sem mover
    println!("Ainda tenho: {}", sensor_id); // ✅ sensor_id ainda é válido

    let mut is_active = false;
    ativar_sensor(&mut is_active);
    println!("Ativo: {}", is_active);   // true
}

fn main() {
    let mut score = 100u64;

    // Múltiplas referências imutáveis: OK
    let r1 = &score;
    let r2 = &score;
    println!("{} {}", r1, r2);

    // Uma referência mutável: OK (r1 e r2 já não são usadas)
    let r3 = &mut score;
    *r3 += 50;
    println!("{}", r3); // 150
}

// Referência mutável → podemos escrever na conta
let sensor = &mut ctx.accounts.sensor_account;
sensor.score = sensor.score.checked_add(delta_score)
    .ok_or(RegistryError::Overflow)?;

// Referência imutável → apenas leitura
let oracle = &ctx.accounts.oracle_account;
let rate = oracle.brl_usdc_rate;

fn main() {
    // Criando um vetor
    let mut observacoes: Vec<u64> = Vec::new();

    // Adicionando elementos
    observacoes.push(172_400);
    observacoes.push(175_000);
    observacoes.push(170_800);

    // Acessando
    println!("Primeira: {}", observacoes[0]);
    println!("Tamanho: {}", observacoes.len());

    // Removendo o primeiro elemento
    if observacoes.len() >= 3 {
        observacoes.remove(0);
    }
    println!("Após remove: {:?}", observacoes);

    // Iterando
    let mut soma: u128 = 0;
    for obs in &observacoes {
        soma += *obs as u128;
    }
    println!("Soma: {}", soma);
}

#[derive(Debug, Clone)]
struct PriceObservation {
    price: u64,
    duration: u64,
    timestamp: i64,
}

const MAX_OBSERVATIONS: usize = 24;

fn main() {
    let mut observations: Vec<PriceObservation> = Vec::new();

    // Adicionando observações
    observations.push(PriceObservation {
        price: 500_000,
        duration: 3600,
        timestamp: 1_700_000_000,
    });
    observations.push(PriceObservation {
        price: 510_000,
        duration: 3600,
        timestamp: 1_700_003_600,
    });

    // Limitando o tamanho (janela deslizante)
    if observations.len() >= MAX_OBSERVATIONS {
        observations.remove(0);
    }

    // Calculando TWAP (Time-Weighted Average Price)
    let mut weighted_sum: u128 = 0;
    let mut total_duration: u128 = 0;
    for obs in &observations {
        weighted_sum += (obs.price as u128) * (obs.duration as u128);
        total_duration += obs.duration as u128;
    }

    if total_duration > 0 {
        let twap = (weighted_sum / total_duration) as u64;
        println!("TWAP: {}", twap);
    }
}

mod registry {
    pub struct Sensor {
        pub id: String,
        pub score: u64,
    }

    impl Sensor {
        pub fn new(id: &str) -> Self {
            Sensor {
                id: id.to_string(),
                score: 0,
            }
        }
    }

    // Função privada (sem pub)
    fn validar_interno(id: &str) -> bool {
        id.len() <= 32
    }

    // Função pública que usa a privada
    pub fn criar_sensor(id: &str) -> Result<Sensor, String> {
        if validar_interno(id) {
            Ok(Sensor::new(id))
        } else {
            Err("ID muito longo".to_string())
        }
    }
}

fn main() {
    let sensor = registry::criar_sensor("temp-001").unwrap();
    println!("Sensor: {} (score: {})", sensor.id, sensor.score);
}

mod protocolo {
    pub const SCALE: u64 = 1_000_000;

    pub mod oracle {
        use super::SCALE;   // acessa constante do módulo pai

        pub fn converter_brl_para_usdc(brl: u64, taxa: u64) -> u64 {
            ((brl as u128) * (taxa as u128) / (SCALE as u128)) as u64
        }
    }

    pub mod treasury {
        use super::SCALE;

        pub fn calcular_partição(receita: u64, bps: u64) -> u64 {
            ((receita as u128) * (bps as u128) / (10_000u128)) as u64
        }
    }
}

fn main() {
    use protocolo::oracle;
    use protocolo::treasury;

    let usdc = oracle::converter_brl_para_usdc(5_000_000_000, 172_400);
    println!("5000 BRL = {} USDC (×10⁶)", usdc);

    let operacional = treasury::calcular_partição(usdc, 4000);
    println!("Operação (40%): {}", operacional);
}

#[program]
pub mod criptosensor_registry {
    use super::*;   // importa tudo que está acima no arquivo (structs, consts, etc.)

    pub fn register_sensor(ctx: Context<RegisterSensor>, sensor_id: String) -> Result<()> {
        // pode acessar MAX_SENSOR_ID_LEN, RegistryError, etc.
        Ok(())
    }
}

trait Pontuavel {
    fn score(&self) -> u64;
    fn esta_ativo(&self) -> bool;

    // Método com implementação padrão
    fn pode_receber_tokens(&self) -> bool {
        self.esta_ativo() && self.score() > 0
    }
}

struct Sensor {
    id: String,
    score: u64,
    is_active: bool,
}

struct EdgeNode {
    id: String,
    score: u64,
    is_active: bool,
}

impl Pontuavel for Sensor {
    fn score(&self) -> u64 { self.score }
    fn esta_ativo(&self) -> bool { self.is_active }
}

impl Pontuavel for EdgeNode {
    fn score(&self) -> u64 { self.score }
    fn esta_ativo(&self) -> bool { self.is_active }
}

fn imprimir_elegibilidade(item: &dyn Pontuavel) {
    println!("Score: {} | Pode receber: {}", item.score(), item.pode_receber_tokens());
}

fn main() {
    let sensor = Sensor { id: "temp-001".to_string(), score: 120, is_active: true };
    let node = EdgeNode { id: "edge-A".to_string(), score: 0, is_active: true };

    imprimir_elegibilidade(&sensor);  // Score: 120 | Pode receber: true
    imprimir_elegibilidade(&node);    // Score: 0 | Pode receber: false
}

#[derive(Debug, Clone, PartialEq)]
struct PriceObservation {
    price: u64,
    duration: u64,
    timestamp: i64,
}

fn main() {
    let obs1 = PriceObservation { price: 500_000, duration: 3600, timestamp: 1_700_000_000 };
    let obs2 = obs1.clone();             // Clone
    println!("{:?}", obs1);              // Debug
    println!("Iguais: {}", obs1 == obs2); // PartialEq
}

// Structs de dados (contas on-chain)
#[account]
#[derive(InitSpace)]
pub struct SensorAccount {
    pub owner: Pubkey,
    #[max_len(32)]
    pub sensor_id: String,
    pub score: u64,
    pub bump: u8,
}

// Structs auxiliares (dentro de contas)
#[derive(AnchorSerialize, AnchorDeserialize, Clone, InitSpace)]
pub struct PriceObservation {
    pub price: u64,
    pub duration: u64,
    pub timestamp: i64,
}

use std::fmt::Display;

fn imprimir_valor<T: Display>(nome: &str, valor: T) {
    println!("{}: {}", nome, valor);
}

fn maior<T: PartialOrd>(a: T, b: T) -> T {
    if a >= b { a } else { b }
}

fn main() {
    imprimir_valor("Score", 150u64);
    imprimir_valor("Sensor", "temp-001");
    println!("Maior: {}", maior(100u64, 200u64));
}

#[derive(Debug)]
struct Resultado<T> {
    valor: T,
    epoch: u64,
    timestamp: i64,
}

fn main() {
    let r1: Resultado<u64> = Resultado { valor: 862_000_000, epoch: 10, timestamp: 1_700_000_000 };
    let r2: Resultado<String> = Resultado { valor: "sucesso".to_string(), epoch: 10, timestamp: 1_700_000_000 };

    println!("{:?}", r1);
    println!("{:?}", r2);
}

// Context<T> — contexto da instrução parametrizado pela struct de contas
pub fn register_sensor(ctx: Context<RegisterSensor>) -> Result<()> { ... }

// Account<'info, T> — conta tipada
pub sensor_account: Account<'info, SensorAccount>,

// Program<'info, T> — referência a um programa
pub system_program: Program<'info, System>,
pub token_program: Program<'info, Token>,

// O lifetime 'a diz: "a referência retornada vive pelo menos
// tanto quanto as referências de entrada"
fn mais_longo<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() { s1 } else { s2 }
}

fn main() {
    let s1 = String::from("temperatura");
    let resultado;
    {
        let s2 = String::from("umidade");
        resultado = mais_longo(&s1, &s2);
        println!("Mais longo: {}", resultado);  // OK: s2 ainda existe aqui
    }
    // Não podemos usar `resultado` aqui se ele referenciasse s2
}

// A struct contém uma referência → precisa de lifetime
struct ConfigView<'a> {
    nome: &'a str,
    versao: &'a str,
}

fn main() {
    let nome = String::from("CriptoSensor");
    let versao = String::from("1.0.0");

    let view = ConfigView {
        nome: &nome,
        versao: &versao,
    };

    println!("{} v{}", view.nome, view.versao);
}

#[derive(Accounts)]
pub struct RegisterSensor<'info> {
    #[account(mut)]
    pub owner: Signer<'info>,
    #[account(init, payer = owner, space = 8 + SensorAccount::INIT_SPACE,
        seeds = [b"sensor", owner.key().as_ref(), sensor_id.as_bytes()],
        bump
    )]
    pub sensor_account: Account<'info, SensorAccount>,
    pub system_program: Program<'info, System>,
}

fn main() {
    let a: u64 = 534_440_000;
    let b: u64 = 951_230;

    // Promove para u128 para evitar overflow no cálculo intermediário
    let resultado = (a as u128) * (b as u128) / (1_000_000u128);
    let final_u64 = resultado as u64;  // volta para u64

    println!("Resultado: {}", final_u64);
}

fn main() {
    let grande: u128 = 999_999_999_999_999;
    let truncado = grande as u64;       // OK (cabe em u64)

    let muito_grande: u128 = u128::MAX;
    let perigoso = muito_grande as u64; // ⚠️ Truncado silenciosamente!

    println!("Truncado: {}", truncado);
    println!("Perigoso: {}", perigoso);
}

fn main() {
    let score: u64 = 100;
    let delta: u64 = 50;

    // checked_add: retorna None se houver overflow
    let novo_score = score.checked_add(delta);
    println!("checked_add: {:?}", novo_score);  // Some(150)

    // checked_mul: retorna None se houver overflow
    let receita: u64 = 534_440_000;
    let bps: u64 = 4000;
    let operacional = receita.checked_mul(bps);
    println!("checked_mul: {:?}", operacional);  // Some(2_137_760_000_000)

    // checked_div: retorna None se divisor for zero
    let por_epoch = receita.checked_div(0);
    println!("checked_div por 0: {:?}", por_epoch);  // None

    // checked_sub: retorna None se resultado for negativo (para unsigned)
    let penalidade: u64 = 200;
    let resultado = score.checked_sub(penalidade);
    println!("checked_sub: {:?}", resultado);  // None (100 - 200 < 0)
}

fn main() {
    let score: u64 = 100;

    // saturating_sub: resultado mínimo = 0 (não estoura para negativo)
    let resultado = score.saturating_sub(200);
    println!("saturating_sub(100, 200) = {}", resultado);  // 0

    let resultado2 = score.saturating_sub(30);
    println!("saturating_sub(100, 30) = {}", resultado2);  // 70
}

fn calcular_partição(receita: u64, bps: u64) -> Result<u64, String> {
    let resultado = receita
        .checked_mul(bps)                               // Option<u64>
        .ok_or("Overflow na multiplicação".to_string())? // Result<u64, String>
        .checked_div(10_000)                             // Option<u64>
        .ok_or("Divisão por zero".to_string())?;         // Result<u64, String>
    Ok(resultado)
}

fn pipeline_completo(receita: u64, taxa: u64, preco: u64) -> Result<u64, String> {
    // Encadeamento completo: receita × taxa / SCALE / preço
    let tokens = (receita as u128)
        .checked_mul(taxa as u128)
        .ok_or("Overflow em receita × taxa".to_string())?
        .checked_div(1_000_000)
        .ok_or("Divisão por escala falhou".to_string())?
        .checked_div(preco as u128)
        .ok_or("Divisão por preço falhou".to_string())?;

    Ok(tokens as u64)
}

fn main() {
    match calcular_partição(862_000_000, 5000) {
        Ok(v) => println!("Incentivo (50%): {} USDC", v),
        Err(e) => println!("Erro: {}", e),
    }

    match pipeline_completo(534_440_000, 951_230, 500_000) {
        Ok(t) => println!("Tokens: {}", t),
        Err(e) => println!("Erro: {}", e),
    }
}

fn main() {
    // println! — imprime com formatação
    let sensor_id = "temp-001";
    let score = 150u64;
    println!("Sensor {} | Score: {}", sensor_id, score);

    // format! — retorna String formatada (sem imprimir)
    let msg = format!("Score do sensor {} atualizado: +{} → total {}", sensor_id, 50, score);
    println!("{}", msg);

    // vec! — cria Vec com valores iniciais
    let precos: Vec<u64> = vec![500_000, 510_000, 505_000];
    println!("{:?}", precos);

    // assert! e assert_eq! — verificações (panic se falhar)
    assert!(score > 0, "Score deve ser positivo");
    assert_eq!(2 + 2, 4, "Matemática quebrou");
}

// declare_id! — define o endereço do programa
declare_id!("REGxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");

// msg! — registra mensagem nos logs da transação (equivale a println! on-chain)
msg!("Sensor registrado: {}", sensor.sensor_id);

// require! — aborta a transação se a condição for falsa
require!(sensor_id.len() <= MAX_SENSOR_ID_LEN, RegistryError::SensorIdTooLong);
require!(amount > 0, TreasuryError::ZeroAmount);

// emit! — emite um evento on-chain que pode ser capturado por indexadores
emit!(PaymentEvent {
    client: ctx.accounts.client.key(),
    amount,
    order_id,
    epoch: treasury.current_epoch,
    timestamp: Clock::get()?.unix_timestamp,
});

// #[derive] — implementa traits automaticamente
#[derive(Debug, Clone, PartialEq)]
struct Ponto {
    x: i64,
    y: i64,
}

// #[allow] — suprime avisos do compilador
#[allow(dead_code)]
fn funcao_nao_usada() {}

// #[cfg] — compilação condicional
#[cfg(test)]
mod tests {
    #[test]
    fn test_soma() {
        assert_eq!(2 + 2, 4);
    }
}

fn main() {
    let p = Ponto { x: 10, y: 20 };
    println!("{:?}", p);
}

// #[program] — marca o módulo como programa Solana
#[program]
pub mod criptosensor_registry {
    // instruções do programa
}

// #[account] — marca struct como conta on-chain (serialização automática)
#[account]
#[derive(InitSpace)]
pub struct SensorAccount {
    pub owner: Pubkey,
    #[max_len(32)]       // #[max_len] — tamanho máximo para cálculo de espaço
    pub sensor_id: String,
    pub score: u64,
    pub bump: u8,
}

// #[derive(Accounts)] — gera validação automática de contas
#[derive(Accounts)]
#[instruction(sensor_id: String)]   // acessa argumentos da instrução
pub struct RegisterSensor<'info> {
    #[account(mut)]      // conta mutável (será modificada)
    pub owner: Signer<'info>,
    #[account(
        init,            // será inicializada (criada)
        payer = owner,   // quem paga o aluguel
        space = 8 + SensorAccount::INIT_SPACE,  // tamanho da conta
        seeds = [b"sensor", owner.key().as_ref(), sensor_id.as_bytes()],
        bump             // PDA bump seed
    )]
    pub sensor_account: Account<'info, SensorAccount>,
    pub system_program: Program<'info, System>,
}

// #[error_code] — define erros customizados
#[error_code]
pub enum RegistryError {
    #[msg("Sensor está inativo")]
    SensorInactive,
}

// #[event] — define evento emitido pela instrução
#[event]
pub struct PaymentEvent {
    pub client: Pubkey,
    pub amount: u64,
    pub timestamp: i64,
}

fn classificar_penalidade(nivel: u8) -> &'static str {
    match nivel {
        0 => "Sem penalidade",
        1 => "Perda parcial de score",
        2 => "Slashing severo",
        3 => "Banimento permanente",
        _ => "Nível desconhecido",   // _ = padrão (wildcard)
    }
}

fn main() {
    for nivel in 0..=4 {
        println!("Nível {}: {}", nivel, classificar_penalidade(nivel));
    }
}

fn main() {
    let resultado: Option<u64> = Some(862_000_000);

    // Ao invés de match completo...
    if let Some(valor) = resultado {
        println!("Receita: {} USDC", valor / 1_000_000);
    }

    // Equivalente a:
    match resultado {
        Some(valor) => println!("Receita: {} USDC", valor / 1_000_000),
        None => {},
    }
}

fn main() {
    let epoch: u64 = 0;
    let revenue: u64 = 500_000_000;
    let ema_anterior: u64 = 0;

    // if-else como expressão
    let new_ema = if epoch == 0 {
        revenue
    } else {
        let alpha = 333_333u64;
        let alpha_r = ((alpha as u128) * (revenue as u128) / 1_000_000) as u64;
        let complement = ((666_667u128) * (ema_anterior as u128) / 1_000_000) as u64;
        alpha_r + complement
    };

    println!("EMA: {}", new_ema);
}

// Cada require! verifica uma condição antes de prosseguir
// Se falhar, retorna erro imediatamente

// require!(condição, Erro);

// Equivalente a:
// if !condição { return Err(Erro.into()); }

// Exemplos do CriptoSensor:
// require!(sensor_id.len() <= MAX_SENSOR_ID_LEN, RegistryError::SensorIdTooLong);
// require!(amount > 0, TreasuryError::ZeroAmount);
// require!(sensor.is_active, RegistryError::SensorInactive);
// require!(penalty_level >= 1 && penalty_level <= 3, RegistryError::InvalidPenalty);

fn soma_slice(valores: &[u64]) -> u128 {
    let mut total: u128 = 0;
    for v in valores {
        total += *v as u128;
    }
    total
}

fn main() {
    let precos: Vec<u64> = vec![500_000, 510_000, 505_000, 515_000];

    // Slice de todo o vetor
    let total = soma_slice(&precos);
    println!("Total: {}", total);

    // Slice parcial
    let ultimos_dois = &precos[2..];
    println!("Últimos dois: {:?}", ultimos_dois);

    // Byte slices — muito usados em seeds de PDA
    let seed: &[u8] = b"sensor";               // byte string literal
    let id_bytes: &[u8] = "temp-001".as_bytes(); // String → bytes

    println!("Seed: {:?}", seed);
    println!("ID bytes: {:?}", id_bytes);

    // Slice de slices (usado em signer_seeds)
    let bump: u8 = 255;
    let seeds: &[&[u8]] = &[b"emission_config".as_ref(), &[bump]];
    println!("Seeds: {:?}", seeds);
}

// --- Constantes ---
const SCALE: u64 = 1_000_000;
const MAX_ID_LEN: usize = 32;
const SENSOR_POOL_BPS: u64 = 7000;
const BPS_BASE: u64 = 10_000;

// --- Enums ---
#[derive(Debug, PartialEq)]
enum ProtoError {
    IdMuitoLongo,
    Overflow,
    SensorInativo,
    ScoreZero,
}

// --- Structs ---
#[derive(Debug, Clone)]
struct Sensor {
    id: String,
    score: u64,
    is_active: bool,
    penalty_level: u8,
}

#[derive(Debug)]
struct EpochResult {
    epoch: u64,
    total_tokens: u64,
    distribuicoes: Vec<(String, u64)>,
}

// --- Traits ---
trait Participante {
    fn id(&self) -> &str;
    fn score(&self) -> u64;
    fn elegivel(&self) -> bool;
}

impl Participante for Sensor {
    fn id(&self) -> &str { &self.id }
    fn score(&self) -> u64 { self.score }
    fn elegivel(&self) -> bool { self.is_active && self.penalty_level < 3 }
}

// --- Implementação ---
impl Sensor {
    fn new(id: &str) -> Result<Self, ProtoError> {
        if id.len() > MAX_ID_LEN {
            return Err(ProtoError::IdMuitoLongo);
        }
        Ok(Sensor {
            id: id.to_string(),
            score: 0,
            is_active: true,
            penalty_level: 0,
        })
    }

    fn adicionar_score(&mut self, delta: u64) -> Result<(), ProtoError> {
        if !self.is_active {
            return Err(ProtoError::SensorInativo);
        }
        self.score = self.score.checked_add(delta)
            .ok_or(ProtoError::Overflow)?;
        Ok(())
    }

    fn aplicar_penalidade(&mut self, nivel: u8, slash: u64) {
        self.penalty_level = nivel;
        self.score = self.score.saturating_sub(slash);
        if nivel >= 3 {
            self.is_active = false;
        }
    }
}

// --- Funções do Protocolo ---

/// Calcula o fator de decaimento e^(-λ·t) via série de Taylor
fn approximate_exp_neg(x: u64) -> Result<u64, ProtoError> {
    if x == 0 { return Ok(SCALE); }

    let x_128 = x as u128;
    let scale_128 = SCALE as u128;

    let x2 = x_128.checked_mul(x_128).ok_or(ProtoError::Overflow)?
        .checked_div(scale_128).ok_or(ProtoError::Overflow)?;
    let x3 = x2.checked_mul(x_128).ok_or(ProtoError::Overflow)?
        .checked_div(scale_128).ok_or(ProtoError::Overflow)?;

    let result = scale_128
        .checked_sub(x_128).unwrap_or(0)
        .checked_add(x2 / 2).ok_or(ProtoError::Overflow)?
        .checked_sub(x3 / 6).unwrap_or(0);

    Ok(result.min(scale_128) as u64)
}

/// Distribui tokens proporcionalmente ao score dos sensores
fn distribuir_tokens(
    sensores: &[Sensor],
    tokens_total: u64,
) -> Result<EpochResult, ProtoError> {
    // Filtra sensores elegíveis
    let elegiveis: Vec<&Sensor> = sensores.iter()
        .filter(|s| s.elegivel())
        .collect();

    let score_total: u64 = elegiveis.iter()
        .map(|s| s.score())
        .sum();

    if score_total == 0 {
        return Err(ProtoError::ScoreZero);
    }

    // Pool de sensores = 70%
    let sensor_pool = (tokens_total as u128)
        .checked_mul(SENSOR_POOL_BPS as u128).ok_or(ProtoError::Overflow)?
        .checked_div(BPS_BASE as u128).ok_or(ProtoError::Overflow)? as u64;

    let mut distribuicoes = Vec::new();
    for sensor in &elegiveis {
        let tokens = (sensor_pool as u128)
            .checked_mul(sensor.score() as u128).ok_or(ProtoError::Overflow)?
            .checked_div(score_total as u128).ok_or(ProtoError::Overflow)? as u64;
        distribuicoes.push((sensor.id().to_string(), tokens));
    }

    Ok(EpochResult {
        epoch: 10,
        total_tokens: tokens_total,
        distribuicoes,
    })
}

// --- Main ---
fn main() {
    println!("═══ Mini-Protocolo CriptoSensor ═══\n");

    // Criar sensores
    let mut sensores = vec![
        Sensor::new("temp-001").unwrap(),
        Sensor::new("umid-002").unwrap(),
        Sensor::new("press-003").unwrap(),
        Sensor::new("spam-004").unwrap(),
    ];

    // Adicionar scores
    sensores[0].adicionar_score(120).unwrap();
    sensores[1].adicionar_score(95).unwrap();
    sensores[2].adicionar_score(60).unwrap();
    sensores[3].adicionar_score(200).unwrap();

    // Banir o spammer
    sensores[3].aplicar_penalidade(3, 200);

    println!("Sensores:");
    for s in &sensores {
        println!("  {} | Score: {} | Ativo: {} | Elegível: {}",
            s.id, s.score, s.is_active, s.elegivel());
    }

    // Calcular decaimento para epoch 10
    let lambda = 5_000u64;  // 0.005 × 10^6
    let epoch = 10u64;
    let x = lambda * epoch / SCALE;
    // x será 0 devido à divisão inteira — usamos o cálculo correto:
    let x_correto = (lambda as u128 * epoch as u128 / (SCALE as u128 / 1000)) as u64;
    // Simplificando: x = 5000 * 10 = 50_000
    let x_final = lambda.checked_mul(epoch).unwrap();

    let decay = approximate_exp_neg(x_final).unwrap();
    println!("\nDecaimento e^(-λ·{}) = {}/{} ≈ {:.6}",
        epoch, decay, SCALE, decay as f64 / SCALE as f64);

    // Tokens do epoch (simulação)
    let incentive_share: u64 = 534_440_000;
    let eligible = (incentive_share as u128 * decay as u128 / SCALE as u128) as u64;
    let token_price: u64 = 500_000;
    let tokens = (eligible as u128 * SCALE as u128 / token_price as u128) as u64;

    println!("Incentive share: {} USDC (×10⁶)", incentive_share);
    println!("Receita elegível: {} USDC (×10⁶)", eligible);
    println!("Tokens emitidos: {} (×10⁶)", tokens);

    // Distribuir
    match distribuir_tokens(&sensores, tokens) {
        Ok(result) => {
            println!("\n═══ Distribuição Epoch {} ═══", result.epoch);
            println!("Pool sensores (70%): {}", tokens * 7 / 10);
            for (id, qtd) in &result.distribuicoes {
                println!("  {} → {} tokens (×10⁶)", id, qtd);
            }
        }
        Err(e) => println!("Erro: {:?}", e),
    }
}