<?php
// upload_tenant_logo.php

// Habilitar logs apenas para debug
error_reporting(E_ALL);
ini_set('display_errors', 0);
ini_set('log_errors', 1);

// Iniciar sessão se não estiver iniciada
if (session_status() === PHP_SESSION_NONE) {
    session_start();
}

// Definir header JSON imediatamente
header('Content-Type: application/json; charset=utf-8');

// Função para enviar resposta JSON padronizada
function jsonResponse($success, $message, $data = []) {
    $response = [
        'success' => $success,
        'message' => $message,
        'data' => $data
    ];
    echo json_encode($response, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    exit;
}

// Verificar se o usuário está logado
if (!isset($_SESSION['logado']) || $_SESSION['logado'] !== true) {
    jsonResponse(false, 'Usuário não logado');
}

// Verificar se é administrador
$permissao = $_SESSION['permissao'] ?? 'usuario';
if (!in_array($permissao, ['admin', 'super_admin'])) {
    jsonResponse(false, 'Apenas administradores podem alterar a logo do tenant');
}

// Verificar se o tenant_id está definido
if (!isset($_SESSION['tenant_id'])) {
    jsonResponse(false, 'Tenant não identificado');
}

$tenant_id = (int)$_SESSION['tenant_id'];
$upload_dir = 'uploads/tenant_logos/';

// Criar diretório se não existir com permissões adequadas
if (!is_dir($upload_dir)) {
    if (!mkdir($upload_dir, 0755, true)) {
        jsonResponse(false, 'Não foi possível criar o diretório de upload. Verifique as permissões.');
    }
    // Criar arquivo .htaccess para proteger a pasta
    $htaccess = $upload_dir . '.htaccess';
    if (!file_exists($htaccess)) {
        file_put_contents($htaccess, "Order Allow,Deny\nAllow from all");
    }
}

// Verificar se existe arquivo
if (!isset($_FILES['tenant_logo'])) {
    jsonResponse(false, 'Nenhum arquivo recebido');
}

$error_code = $_FILES['tenant_logo']['error'];
if ($error_code !== UPLOAD_ERR_OK) {
    $error_messages = [
        UPLOAD_ERR_INI_SIZE => 'Arquivo muito grande (limite do servidor)',
        UPLOAD_ERR_FORM_SIZE => 'Arquivo muito grande (limite do formulário)',
        UPLOAD_ERR_PARTIAL => 'Upload parcialmente feito',
        UPLOAD_ERR_NO_FILE => 'Nenhum arquivo selecionado',
        UPLOAD_ERR_NO_TMP_DIR => 'Pasta temporária não encontrada',
        UPLOAD_ERR_CANT_WRITE => 'Erro ao escrever no disco',
        UPLOAD_ERR_EXTENSION => 'Extensão não permitida'
    ];
    
    $error_msg = $error_messages[$error_code] ?? 'Erro desconhecido no upload (Código: ' . $error_code . ')';
    jsonResponse(false, $error_msg);
}

$file_tmp = $_FILES['tenant_logo']['tmp_name'];
$file_size = $_FILES['tenant_logo']['size'];

// Validar tamanho do arquivo (máximo 5MB)
if ($file_size > 5 * 1024 * 1024) {
    jsonResponse(false, 'Arquivo muito grande. Tamanho máximo: 5MB.');
}

// Verificar se o arquivo é realmente uma imagem
$image_info = @getimagesize($file_tmp);
if (!$image_info) {
    jsonResponse(false, 'O arquivo não é uma imagem válida.');
}

// Validar tipo de imagem
$allowed_mimes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp'];
$mime_type = $image_info['mime'];
if (!in_array($mime_type, $allowed_mimes)) {
    jsonResponse(false, 'Tipo de arquivo não permitido. Use JPG, PNG, GIF ou WebP.');
}

// Gerar nome de arquivo seguro
$extension_map = [
    'image/jpeg' => 'jpg',
    'image/jpg' => 'jpg',
    'image/png' => 'png',
    'image/gif' => 'gif',
    'image/webp' => 'webp'
];

$extension = $extension_map[$mime_type] ?? 'png';
$file_name = "tenant_logo_{$tenant_id}_" . time() . '.' . $extension;
$file_path = $upload_dir . $file_name;

// Processar a imagem
try {
    // Criar imagem a partir do arquivo
    switch ($mime_type) {
        case 'image/jpeg':
        case 'image/jpg':
            $image = imagecreatefromjpeg($file_tmp);
            $save_function = 'imagejpeg';
            $quality = 85;
            break;
        case 'image/png':
            $image = imagecreatefrompng($file_tmp);
            // Manter transparência
            imagealphablending($image, false);
            imagesavealpha($image, true);
            $save_function = 'imagepng';
            $quality = 8;
            break;
        case 'image/gif':
            $image = imagecreatefromgif($file_tmp);
            $save_function = 'imagegif';
            $quality = null;
            break;
        case 'image/webp':
            $image = imagecreatefromwebp($file_tmp);
            $save_function = 'imagewebp';
            $quality = 80;
            break;
        default:
            throw new Exception('Tipo de imagem não suportado');
    }

    if (!$image) {
        throw new Exception('Não foi possível criar a imagem a partir do arquivo');
    }

    // Redimensionar para tamanho máximo de 200x200px mantendo proporção
    $max_width = 200;
    $max_height = 200;

    $orig_width = imagesx($image);
    $orig_height = imagesy($image);

    // Calcular novas dimensões mantendo proporção
    $ratio = $orig_width / $orig_height;
    
    if ($max_width / $max_height > $ratio) {
        $new_width = $max_height * $ratio;
        $new_height = $max_height;
    } else {
        $new_width = $max_width;
        $new_height = $max_width / $ratio;
    }

    // Arredondar para inteiros
    $new_width = round($new_width);
    $new_height = round($new_height);

    // Criar nova imagem
    $new_image = imagecreatetruecolor($new_width, $new_height);
    
    if (!$new_image) {
        imagedestroy($image);
        throw new Exception('Não foi possível criar nova imagem');
    }
    
    // Manter transparência para PNG/WebP/GIF
    if ($mime_type === 'image/png' || $mime_type === 'image/webp' || $mime_type === 'image/gif') {
        imagealphablending($new_image, false);
        imagesavealpha($new_image, true);
        $transparent = imagecolorallocatealpha($new_image, 255, 255, 255, 127);
        imagefilledrectangle($new_image, 0, 0, $new_width, $new_height, $transparent);
    } else {
        // Fundo branco para JPEG
        $white = imagecolorallocate($new_image, 255, 255, 255);
        imagefill($new_image, 0, 0, $white);
    }

    // Redimensionar
    if (!imagecopyresampled($new_image, $image, 0, 0, 0, 0, $new_width, $new_height, $orig_width, $orig_height)) {
        imagedestroy($image);
        imagedestroy($new_image);
        throw new Exception('Erro ao redimensionar imagem');
    }

    // Salvar a imagem
    if ($quality !== null) {
        $result = $save_function($new_image, $file_path, $quality);
    } else {
        $result = $save_function($new_image, $file_path);
    }

    // Liberar memória
    imagedestroy($image);
    imagedestroy($new_image);

    if (!$result) {
        throw new Exception('Não foi possível salvar a imagem. Verifique permissões da pasta.');
    }

    // Conectar ao banco de dados
    require_once 'conexao.php';
    
    if (!isset($conn) || !($conn instanceof mysqli)) {
        throw new Exception('Erro de conexão com o banco de dados');
    }

    // Verificar conexão
    if ($conn->connect_error) {
        throw new Exception('Falha na conexão com o banco de dados: ' . $conn->connect_error);
    }

    // Verificar se existe logo anterior para deletar o arquivo
    $old_logo = null;
    $stmt = $conn->prepare("SELECT logo_path FROM tenants WHERE id = ?");
    if (!$stmt) {
        throw new Exception('Erro ao preparar consulta: ' . $conn->error);
    }
    
    $stmt->bind_param("i", $tenant_id);
    if (!$stmt->execute()) {
        $stmt->close();
        throw new Exception('Erro ao executar consulta: ' . $stmt->error);
    }
    
    $result = $stmt->get_result();
    if ($row = $result->fetch_assoc()) {
        $old_logo = $row['logo_path'];
    }
    $stmt->close();
    
    // Deletar arquivo antigo se existir e for diferente do novo
    if ($old_logo && file_exists($old_logo) && $old_logo !== $file_path) {
        @unlink($old_logo);
    }

    // Atualizar o caminho da logo no banco de dados
    $stmt = $conn->prepare("UPDATE tenants SET logo_path = ? WHERE id = ?");
    if (!$stmt) {
        throw new Exception('Erro ao preparar atualização: ' . $conn->error);
    }
    
    $stmt->bind_param("si", $file_path, $tenant_id);
    
    if ($stmt->execute()) {
        $stmt->close();
        
        // Retornar caminho relativo para uso no HTML
        $relative_path = $file_path;
        
        jsonResponse(true, 'Logo atualizada com sucesso', [
            'logo_path' => $relative_path,
            'logo_url' => $relative_path,
            'timestamp' => time()
        ]);
    } else {
        throw new Exception('Erro ao atualizar banco de dados: ' . $stmt->error);
    }

} catch (Exception $e) {
    // Limpar arquivo criado se existir
    if (isset($file_path) && file_exists($file_path)) {
        @unlink($file_path);
    }
    
    // Log do erro para debug
    error_log("Erro no upload_tenant_logo.php [Tenant: {$tenant_id}]: " . $e->getMessage());
    
    jsonResponse(false, 'Erro: ' . $e->getMessage());
}
?>