// build.zig — compilar biblioteca para Android e iOS
const std = @import("std");

pub fn build(b: *std.Build) void {
    const optimize = b.standardOptimizeOption(.{});

    const mobile_targets = [_]struct {
        query: std.Target.Query,
        nome: []const u8,
    }{
        // Android
        .{ .query = .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .android }, .nome = "android-arm64" },
        .{ .query = .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .android }, .nome = "android-x86_64" },
        // iOS
        .{ .query = .{ .cpu_arch = .aarch64, .os_tag = .ios }, .nome = "ios-arm64" },
        // iOS Simulator
        .{ .query = .{ .cpu_arch = .x86_64, .os_tag = .ios }, .nome = "ios-simulator-x86_64" },
    };

    for (mobile_targets) |mt| {
        const target = b.resolveTargetQuery(mt.query);
        const lib = b.addSharedLibrary(.{
            .name = "minha_lib",
            .root_source_file = b.path("src/lib.zig"),
            .target = target,
            .optimize = optimize,
        });
        b.installArtifact(lib);
    }
}

// src/lib.zig — lógica compartilhada entre Android e iOS
const std = @import("std");

// API exportada com convenção C para interop
export fn calcularHash(dados: [*]const u8, len: usize) u64 {
    const slice = dados[0..len];
    return std.hash.Wyhash.hash(0, slice);
}

export fn comprimirDados(
    entrada: [*]const u8,
    entrada_len: usize,
    saida: [*]u8,
    saida_len: *usize,
) bool {
    const src = entrada[0..entrada_len];
    var dest = saida[0..saida_len.*];

    var stream = std.compress.zlib.compressor(.{}, std.io.fixedBufferStream(dest).writer());
    stream.writer().writeAll(src) catch return false;
    stream.finish() catch return false;

    saida_len.* = stream.bytesWritten();
    return true;
}

export fn validarCPF(cpf_ptr: [*]const u8, cpf_len: usize) bool {
    const cpf = cpf_ptr[0..cpf_len];
    if (cpf.len != 11) return false;

    // Verificar se todos os dígitos são iguais
    const primeiro = cpf[0];
    var todos_iguais = true;
    for (cpf[1..]) |c| {
        if (c != primeiro) { todos_iguais = false; break; }
    }
    if (todos_iguais) return false;

    // Calcular primeiro dígito verificador
    var soma: u32 = 0;
    for (0..9) |i| {
        soma += (cpf[i] - '0') * @as(u32, @intCast(10 - i));
    }
    var resto = (soma * 10) % 11;
    if (resto == 10) resto = 0;
    if (resto != cpf[9] - '0') return false;

    // Calcular segundo dígito verificador
    soma = 0;
    for (0..10) |i| {
        soma += (cpf[i] - '0') * @as(u32, @intCast(11 - i));
    }
    resto = (soma * 10) % 11;
    if (resto == 10) resto = 0;
    return resto == cpf[10] - '0';
}

class ZigLib {
    companion object {
        init { System.loadLibrary("minha_lib") }
    }
    external fun calcularHash(dados: ByteArray): Long
    external fun validarCPF(cpf: String): Boolean
}

// Uso
val hash = ZigLib().calcularHash("dados".toByteArray())
val valido = ZigLib().validarCPF("12345678909")

// Bridging header
import Foundation

@_silgen_name("calcularHash")
func zigCalcHash(_ data: UnsafePointer<UInt8>, _ len: Int) -> UInt64

@_silgen_name("validarCPF")
func zigValidarCPF(_ cpf: UnsafePointer<UInt8>, _ len: Int) -> Bool

// Uso
let dados = "teste".data(using: .utf8)!
let hash = dados.withUnsafeBytes { zigCalcHash($0.baseAddress!, dados.count) }