(async () => {
    // Carrega a biblioteca ONNX.js dinamicamente
    if (typeof onnx === 'undefined') {
        const script = document.createElement('script');
        script.src = 'https://cdn.jsdelivr.net/npm/onnxjs/dist/onnx.min.js';
        document.head.appendChild(script);
        await new Promise(resolve => script.onload = resolve);
    }

    // URL do modelo ONNX
    const modelUrl = 'https://storage.googleapis.com/dados-publicos-para-treinamento/best.onnx'; // Seu modelo hospedado localmente

    // Carrega o modelo
    const session = new onnx.InferenceSession();
    try {
        await session.loadModel(modelUrl);
        console.log("Modelo YOLO carregado com sucesso");
    } catch (e) {
        console.error("Erro ao carregar modelo:", e);
        return;
    }

    // Função para processar imagens
    async function processImages() {
        const images = document.getElementsByTagName('img');
        for (let img of images) {
            if (img.dataset.processed) continue;
            img.dataset.processed = "true";

            try {
                // Cria um canvas para manipular a imagem
                const canvas = document.createElement('canvas');
                canvas.width = 640;  // Tamanho esperado pelo modelo (ajuste se necessário)
                canvas.height = 640;
                const ctx = canvas.getContext('2d');

                // Redimensiona a imagem
                img.crossOrigin = "anonymous"; // Tenta evitar CORS
                ctx.drawImage(img, 0, 0, 640, 640);

                // Obtém os dados da imagem
                const imageData = ctx.getImageData(0, 0, 640, 640);
                const pixels = imageData.data;

                // Preprocessa os dados (normalização para [0, 1])
                const tensorData = new Float32Array(640 * 640 * 3);
                for (let i = 0, j = 0; i < pixels.length; i += 4, j += 3) {
                    tensorData[j] = pixels[i] / 255.0;     // R
                    tensorData[j + 1] = pixels[i + 1] / 255.0; // G
                    tensorData[j + 2] = pixels[i + 2] / 255.0; // B
                }
                const inputTensor = new onnx.Tensor(tensorData, 'float32', [1, 3, 640, 640]);

                // Executa a inferência
                const outputMap = await session.run([inputTensor]);
                const output = outputMap.values().next().value.data;

                // Processa a saída (assumindo classificação)
                const classId = output.indexOf(Math.max(...output));
                const confidence = output[classId];

                // Nomes das classes (substitua pelos seus)
                const classNames = ["classe1", "classe2", "classe3"]; // Ajuste conforme seu modelo
                const className = classNames[classId] || `Classe_${classId}`;

                // Desenha o resultado no canto superior direito
                ctx.font = '20px Arial';
                ctx.fillStyle = 'rgba(255, 255, 0, 0.7)'; // Fundo amarelo
                const label = `${className} (${confidence.toFixed(2)})`;
                const textWidth = ctx.measureText(label).width;
                ctx.fillRect(640 - textWidth - 15, 5, textWidth + 10, 25);
                ctx.fillStyle = 'red';
                ctx.textAlign = 'right';
                ctx.fillText(label, 630, 25);

                // Substitui a imagem original
                img.src = canvas.toDataURL('image/png');
            } catch (e) {
                console.error("Erro ao processar imagem:", e);
            }
        }
    }

    // Executa o processamento
    await processImages();
    console.log("Processamento concluído");
})();