<?php
/**
 * Helper de Upload de Imagens - Checkout Pro 2025
 * 
 * Funções auxiliares para upload e validação de imagens
 */

/**
 * Faz upload de uma imagem e retorna a URL pública
 * 
 * @param array $file Arquivo do $_FILES
 * @param string $subfolder Subpasta onde salvar (ex: 'produtos', 'orderbumps')
 * @param int $max_size Tamanho máximo em bytes (padrão: 5MB)
 * @return string|false Retorna a URL pública da imagem ou false em caso de erro
 */
function upload_imagem($file, $subfolder = 'produtos', $max_size = 5242880) {
    // Verificar se o arquivo foi enviado
    if (!isset($file) || !is_array($file) || !isset($file['error'])) {
        throw new Exception("Arquivo não foi enviado corretamente.");
    }
    
    if ($file['error'] !== UPLOAD_ERR_OK) {
        if ($file['error'] === UPLOAD_ERR_NO_FILE) {
            throw new Exception("Nenhum arquivo foi selecionado.");
        }
        $error_messages = [
            UPLOAD_ERR_INI_SIZE => 'Arquivo excede o tamanho máximo permitido pelo servidor.',
            UPLOAD_ERR_FORM_SIZE => 'Arquivo excede o tamanho máximo permitido pelo formulário.',
            UPLOAD_ERR_PARTIAL => 'Upload foi interrompido.',
            UPLOAD_ERR_NO_TMP_DIR => 'Diretório temporário não encontrado.',
            UPLOAD_ERR_CANT_WRITE => 'Falha ao escrever arquivo no disco.',
            UPLOAD_ERR_EXTENSION => 'Upload bloqueado por extensão.'
        ];
        $error_msg = isset($error_messages[$file['error']]) ? $error_messages[$file['error']] : "Erro desconhecido (código: {$file['error']})";
        error_log("Erro no upload: código {$file['error']} - {$error_msg}");
        throw new Exception("Erro ao fazer upload da imagem: {$error_msg}");
    }
    
    // Validar tipo de arquivo
    $allowed_types = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'];
    $finfo = finfo_open(FILEINFO_MIME_TYPE);
    $mime_type = finfo_file($finfo, $file['tmp_name']);
    finfo_close($finfo);
    
    if (!in_array($mime_type, $allowed_types)) {
        throw new Exception("Tipo de arquivo não permitido. Apenas JPG, PNG e WEBP são aceitos.");
    }
    
    // Validar extensão
    $extension = strtolower(pathinfo($file['name'], PATHINFO_EXTENSION));
    $allowed_extensions = ['jpg', 'jpeg', 'png', 'webp'];
    if (!in_array($extension, $allowed_extensions)) {
        throw new Exception("Extensão de arquivo não permitida. Apenas JPG, PNG e WEBP são aceitos.");
    }
    
    // Validar tamanho
    if ($file['size'] > $max_size) {
        $max_size_mb = round($max_size / 1048576, 2);
        throw new Exception("Arquivo muito grande. Tamanho máximo: {$max_size_mb}MB");
    }
    
    // Definir diretório base (relativo à raiz do projeto)
    // Usar ROOT_PATH se disponível, senão usar __DIR__
    if (defined('ROOT_PATH')) {
        $base_dir = ROOT_PATH . '/public/uploads/' . $subfolder . '/';
    } else {
        $base_dir = dirname(__DIR__) . '/public/uploads/' . $subfolder . '/';
    }
    
    // Normalizar caminho (garantir barras corretas)
    $base_dir = str_replace('\\', '/', $base_dir);
    $base_dir = rtrim($base_dir, '/') . '/';
    
    // Criar diretório se não existir (com permissões)
    if (!is_dir($base_dir)) {
        if (!@mkdir($base_dir, 0755, true)) {
            // Tentar criar diretórios pai se necessário
            $parent_dir = dirname($base_dir);
            if (!is_dir($parent_dir)) {
                @mkdir($parent_dir, 0755, true);
            }
            if (!@mkdir($base_dir, 0755, true)) {
                error_log("Erro ao criar diretório: {$base_dir}. Verifique permissões.");
                throw new Exception("Não foi possível criar o diretório de uploads: {$base_dir}");
            }
        }
    }
    
    // Verificar permissões de escrita
    if (!is_writable($base_dir)) {
        error_log("Diretório sem permissão de escrita: {$base_dir}");
        throw new Exception("O diretório de uploads não tem permissão de escrita. Verifique as permissões do diretório.");
    }
    
    // Gerar nome único para o arquivo
    $nome_unico = md5(time() . $file['name'] . uniqid()) . '.' . $extension;
    $caminho_completo = $base_dir . $nome_unico;
    
    // Mover arquivo
    if (!move_uploaded_file($file['tmp_name'], $caminho_completo)) {
        throw new Exception("Erro ao salvar o arquivo no servidor.");
    }
    
    // Retornar URL pública
    $protocol = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
    $host = $_SERVER['HTTP_HOST'];
    $base_path = str_replace($_SERVER['DOCUMENT_ROOT'], '', __DIR__);
    $base_path = str_replace('/backend', '', $base_path);
    
    // Construir URL relativa (mais seguro)
    $url_relativa = '/public/uploads/' . $subfolder . '/' . $nome_unico;
    
    // Retornar URL completa
    return $protocol . '://' . $host . $url_relativa;
}

/**
 * Processa campo de imagem (upload ou URL)
 * Prioriza upload se houver arquivo, senão usa URL do campo texto
 * 
 * @param array|null $file Arquivo do $_FILES['campo_imagem'] ou null
 * @param string $url_input URL do campo de input (pode estar vazio)
 * @param string $subfolder Subpasta onde salvar (ex: 'produtos', 'orderbumps')
 * @return string|null URL da imagem (upload ou URL externa), ou null se não houver arquivo nem URL
 */
function processar_imagem($file, $url_input = '', $subfolder = 'produtos') {
    // Verificar se um arquivo foi realmente enviado
    if ($file !== null && isset($file['error'])) {
        // Se há erro diferente de "nenhum arquivo", lançar exceção
        if ($file['error'] !== UPLOAD_ERR_OK && $file['error'] !== UPLOAD_ERR_NO_FILE) {
            throw new Exception("Erro no upload: código " . $file['error']);
        }
        
        // Se arquivo foi enviado com sucesso, fazer upload
        if ($file['error'] === UPLOAD_ERR_OK && isset($file['tmp_name']) && !empty($file['tmp_name']) && is_uploaded_file($file['tmp_name'])) {
            try {
                return upload_imagem($file, $subfolder);
            } catch (Exception $e) {
                error_log("Erro no upload de imagem: " . $e->getMessage());
                throw $e;
            }
        }
    }
    
    // Se não houver arquivo enviado, usar URL do input (se preenchida)
    if (!empty(trim($url_input))) {
        return trim($url_input);
    }
    
    // Se não houver nem arquivo nem URL, retornar null (não atualizar)
    return null;
}







