const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Olá, {s}!\n", .{"mundo"});
}

// Constantes (imutáveis) - preferidas em Zig
const x: i32 = 42;
const nome = "Zig";  // tipo inferido: *const [3:0]u8

// Variáveis (mutáveis)
var contador: u32 = 0;
contador += 1;

// Sem tipo explícito (inferência)
const pi = 3.14159;  // comptime_float
var flag = true;      // bool

// Undefined - valor não inicializado
var buffer: [100]u8 = undefined;

// Comentário de linha única

/// Comentário de documentação (doc comment)
/// Aparece na documentação gerada automaticamente
pub fn minhaFuncao() void {}

//! Comentário de módulo (top-level doc comment)
//! Descreve o propósito do arquivo/módulo

const a: i32 = 10;
const b: i32 = 3;

const soma = a + b;        // 13
const subtracao = a - b;    // 7
const multiplicacao = a * b; // 30
const divisao = @divTrunc(a, b); // 3 (divisão truncada)
const modulo = @mod(a, b);       // 1
const negacao = -a;              // -10

// Operações com overflow checked (padrão)
// Se houver overflow, é um erro de runtime detectável

// Operações com wrapping (sem verificação de overflow)
const wrap_add = a +% b;  // wrapping add
const wrap_mul = a *% b;  // wrapping multiply

// Operações saturadas
const sat_add = a +| b;   // saturating add
const sat_sub = a -| b;   // saturating subtract

const x: u8 = 0b1010_1010;
const y: u8 = 0b1100_1100;

const and_result = x & y;    // AND: 0b1000_1000
const or_result = x | y;     // OR:  0b1110_1110
const xor_result = x ^ y;    // XOR: 0b0110_0110
const not_result = ~x;       // NOT: 0b0101_0101
const shl_result = x << 2;   // Shift left
const shr_result = x >> 2;   // Shift right

const a: i32 = 5;
const b: i32 = 10;

const igual = (a == b);          // false
const diferente = (a != b);      // true
const menor = (a < b);           // true
const maior = (a > b);           // false
const menor_igual = (a <= b);    // true
const maior_igual = (a >= b);    // false

const x = true;
const y = false;

const e_logico = x and y;    // false
const ou_logico = x or y;    // true
const negacao_logica = !x;   // false

// Inteiros
const decimal = 42;
const hexadecimal = 0xFF;
const octal = 0o77;
const binario = 0b1010_1111;

// Separadores visuais com underscore
const milhao = 1_000_000;
const hex_grande = 0xFF_FF_FF_FF;

// Ponto flutuante
const float1 = 3.14;
const float2 = 1.0e10;
const float3 = 0x1.0p10;  // hexadecimal float

// String literal (array de bytes terminado em sentinela)
const saudacao = "Olá, mundo!";

// Caractere (u8)
const letra: u8 = 'A';

// String multilinha
const texto_longo =
    \\Esta é uma string
    \\que ocupa várias linhas
    \\sem necessidade de concatenação
;

// Sequências de escape
const nova_linha = "linha1\nlinha2";
const tab = "col1\tcol2";
const aspas = "ele disse \"olá\"";
const barra = "caminho\\arquivo";
const nulo = "texto\x00nulo";  // byte nulo

// Blocos nomeados com valor de retorno
const resultado = blk: {
    var temp: i32 = 10;
    temp *= 2;
    break :blk temp;  // retorna 20
};

// Blocos simples para escopo
{
    var temp: i32 = 42;
    _ = temp;
    // temp não é acessível fora deste bloco
}

var x: i32 = 10;

x += 5;   // x = x + 5  → 15
x -= 3;   // x = x - 3  → 12
x *= 2;   // x = x * 2  → 24
x /= 4;   // compilador rejeita para inteiros — use @divTrunc
x %= 3;   // compilador rejeita — use @mod ou @rem

// Atribuição com bit a bit
var y: u8 = 0xFF;
y &= 0x0F;  // AND
y |= 0xF0;  // OR
y ^= 0xFF;  // XOR
y <<= 2;    // shift left
y >>= 1;    // shift right

const x: i32 = 42;

// Conversão segura (widening)
const y: i64 = x;  // i32 → i64 é sempre seguro

// Conversão explícita com @intCast
const z: i16 = @intCast(x);  // pode falhar se valor não couber

// @as para casting explícito
const w = @as(f64, 3.14);

// Conversão entre inteiro e float
const float_val: f32 = @floatFromInt(x);
const int_val: i32 = @intFromFloat(float_val);

// Truncamento
const grande: u16 = 1000;
const pequeno: u8 = @truncate(grande);  // trunca bits superiores

// Tipo optional: pode ser null ou um valor
var maybe_valor: ?i32 = null;
maybe_valor = 42;

// Desempacotar com if
if (maybe_valor) |valor| {
    // valor é i32, não ?i32
    std.debug.print("Valor: {}\n", .{valor});
}

// Desempacotar com orelse
const valor = maybe_valor orelse 0;  // 42 ou 0 se null

// Forçar desempacotamento (panic se null)
const forcar = maybe_valor.?;

// Array com sentinela
const nome: [:0]const u8 = "Zig";  // terminado em null

// Verificar sentinela
const arr: [5:0]u8 = .{ 'h', 'e', 'l', 'l', 'o' };
// arr[5] == 0 (sentinela)

pub fn exemplo() !void {
    var recurso = try abrirRecurso();
    defer recurso.fechar();  // executa ao sair do escopo

    errdefer std.debug.print("Erro ao processar!\n", .{});
    // errdefer só executa se a função retornar erro

    try processarRecurso(recurso);
}

const std = @import("std");

// Debug print (stderr) — mais simples
std.debug.print("Debug: x = {}\n", .{x});

// Stdout formatado
const stdout = std.io.getStdOut().writer();
try stdout.print("Valor: {d}\n", .{42});
try stdout.print("String: {s}\n", .{"olá"});
try stdout.print("Hex: 0x{x}\n", .{255});
try stdout.print("Binário: {b}\n", .{42});

// Log
std.log.info("Informação: {}", .{valor});
std.log.warn("Aviso: {}", .{msg});
std.log.err("Erro: {}", .{err});