// Zig suporta inteiros de qualquer tamanho de 1 a 65535 bits
const meu_u3: u3 = 7;        // 3 bits: 0 a 7
const meu_i5: i5 = -16;      // 5 bits: -16 a 15
const meu_u12: u12 = 4095;   // 12 bits: 0 a 4095
const meu_u1: u1 = 1;        // 1 bit: 0 ou 1

const pi: f64 = 3.14159265358979;
const euler: f32 = 2.71828;

// Valores especiais
const inf = std.math.inf(f64);        // infinito
const neg_inf = -std.math.inf(f64);   // infinito negativo
const nan = std.math.nan(f64);        // NaN

// Verificações
const eh_nan = std.math.isNan(valor);
const eh_inf = std.math.isInf(valor);

const verdadeiro: bool = true;
const falso: bool = false;

// Operações lógicas
const resultado = verdadeiro and falso;  // false
const resultado2 = verdadeiro or falso;  // true
const resultado3 = !verdadeiro;          // false

// Conversão para inteiro
const como_int: u1 = @intFromBool(verdadeiro);  // 1
const como_bool: bool = @as(bool, @as(u1, 1));  // true

// void ocupa 0 bytes
const v: void = {};

// Usado como retorno de funções sem resultado
fn fazAlgo() void {
    // sem retorno
}

// Usado em tipos genéricos para "não ter valor"
const MapaSemValor = std.AutoHashMap([]const u8, void);

// Array de tamanho fixo
const numeros: [5]i32 = .{ 1, 2, 3, 4, 5 };

// Com tamanho inferido
const letras = [_]u8{ 'a', 'b', 'c' };

// Array com valor padrão
const zeros: [100]u8 = .{0} ** 100;
const padrao = [_]i32{-1} ** 10;  // [-1, -1, ..., -1]

// Array multidimensional
const matrix: [3][3]f32 = .{
    .{ 1.0, 0.0, 0.0 },
    .{ 0.0, 1.0, 0.0 },
    .{ 0.0, 0.0, 1.0 },
};

// Acesso
const primeiro = numeros[0];  // 1
const tamanho = numeros.len;  // 5

// Array com sentinela
const str: [5:0]u8 = .{ 'h', 'e', 'l', 'l', 'o' };
// str[5] é 0 (o sentinela)

const array = [_]i32{ 1, 2, 3, 4, 5 };

// Criar slice a partir de array
const slice: []const i32 = array[1..4];  // {2, 3, 4}
const slice_ate_fim: []const i32 = array[2..];  // {3, 4, 5}

// Slice mutável
var mut_array = [_]i32{ 1, 2, 3 };
var mut_slice: []i32 = &mut_array;
mut_slice[0] = 10;

// Propriedades
const ptr = slice.ptr;  // ponteiro para o primeiro elemento
const len = slice.len;  // comprimento

// Tipo optional: ?T pode ser null ou T
var talvez: ?i32 = null;
talvez = 42;

// Desempacotar
if (talvez) |valor| {
    // valor é i32
    std.debug.print("{}\n", .{valor});
} else {
    // é null
}

// orelse — fornecer valor padrão
const seguro = talvez orelse 0;

// .? — forçar desempacotamento (panic se null)
const forcado = talvez.?;

// Optional de ponteiro
var ptr: ?*i32 = null;

// Definir conjunto de erros
const MeuErro = error{
    ArquivoNaoEncontrado,
    PermissaoNegada,
    Timeout,
};

// Error union: !T pode ser erro ou T
fn dividir(a: f64, b: f64) !f64 {
    if (b == 0.0) return error.DivisaoPorZero;
    return a / b;
}

// Capturar erros
const resultado = dividir(10, 0) catch |err| {
    std.debug.print("Erro: {}\n", .{err});
    return;
};

// try — propagar erro
const valor = try dividir(10, 2);

// Ponteiro simples
var x: i32 = 42;
const ptr: *i32 = &x;
ptr.* = 100;  // dereferenciar e atribuir

// Ponteiro constante
const cptr: *const i32 = &x;
// cptr.* = 50;  // ERRO: não pode modificar

// Ponteiro para muitos elementos
const array = [_]i32{ 1, 2, 3, 4, 5 };
const mptr: [*]const i32 = &array;

// Ponteiro optional
var optr: ?*i32 = null;
optr = &x;

// Ponteiro com alinhamento
const aptr: *align(16) i32 = @alignCast(&x);

// comptime_int — inteiro de precisão arbitrária (só existe em comptime)
const big = 100000000000000000000;  // comptime_int

// comptime_float — float de precisão estendida
const precise = 3.14159265358979323846;  // comptime_float

// type — o tipo de um tipo (só existe em comptime)
const T: type = i32;
var valor: T = 42;

// noreturn — função que nunca retorna
fn panico() noreturn {
    @panic("erro fatal");
}

const Cor = enum {
    vermelho,
    verde,
    azul,
};

const cor: Cor = .verde;

// Enum com tipo inteiro
const Status = enum(u8) {
    ativo = 1,
    inativo = 0,
    pendente = 2,
};

// Converter para inteiro
const valor = @intFromEnum(Status.ativo);  // 1
const status = @enumFromInt(1);  // Status.ativo

const Ponto = struct {
    x: f64,
    y: f64,
    z: f64 = 0.0,  // valor padrão

    // Método
    pub fn distancia(self: Ponto, outro: Ponto) f64 {
        const dx = self.x - outro.x;
        const dy = self.y - outro.y;
        return @sqrt(dx * dx + dy * dy);
    }
};

const p = Ponto{ .x = 1.0, .y = 2.0 };
const d = p.distancia(Ponto{ .x = 4.0, .y = 6.0 });

// Struct anônima (tuple)
const tupla: struct { i32, []const u8 } = .{ 42, "olá" };

// Tagged union
const Valor = union(enum) {
    inteiro: i64,
    float: f64,
    texto: []const u8,
    nenhum: void,
};

const v = Valor{ .inteiro = 42 };

switch (v) {
    .inteiro => |i| std.debug.print("Int: {}\n", .{i}),
    .float => |f| std.debug.print("Float: {d}\n", .{f}),
    .texto => |t| std.debug.print("Texto: {s}\n", .{t}),
    .nenhum => std.debug.print("Nenhum\n", .{}),
}