Code.ts

// =================================================================
// ARQUIVO DE LÓGICA CENTRAL (TYPESCRIPT)
// =================================================================

// --- TIPOS E INTERFACES GLOBAIS ---
// Adicionando referências de tipo para os serviços do Google Apps Script
/// <reference types="google-apps-script" />

// Use the correct GAS event type name (DoGet) or fallback to any if needed
type GASEvent = GoogleAppsScript.Events.DoGet;
type HTMLOutput = GoogleAppsScript.HTML.HtmlOutput;
type Sheet = GoogleAppsScript.Spreadsheet.Sheet;
type Spreadsheet = GoogleAppsScript.Spreadsheet.Spreadsheet;

// --- INTERFACES CUSTOMIZADAS PARA A APLICAÇÃO ---

interface SheetCache {
  [key: string]: Spreadsheet;
}

interface ValidationResult {
  isValid: boolean;
  message: string;
}

interface LongTermRuleResult {
  isApplicable: boolean;
  isValid: boolean;
  message: string;
}

interface HeadersAndData {
  data: any[][];
  headers: string[];
  headerRowIndex: number;
  error?: string;
}

interface User {
  email: string;
  role: string;
  permissions: StringMap;
}

interface RequestData {
  material: string;
  descricao: string;
  fornecedor: string;
  bandeira: string;
  loja: string;
  precoDe: number;
  precoPor: number;
  descPercent: string;
  dataInicio: string;
  dataFim: string;
  recompMargem: string;
  valorRebate: string;
  obsComercial: string;
  nRebaixa: string;
  nAcao: string;
  mecanica?: string;
}

interface UpdateRequestData {
  itemId: string;
  newStatus: string;
  reason?: string;
}

interface UpdateDetailsPayload {
  itemId: string;
  details: {
    recompMargem: string;
    valorRebate: string;
    nRebaixa: string;
  };
}

interface ProductInfo {
  sku: string;
  descricao: string;
  categoriaN3: string;
  categoriaN4: string;
  fornecedor: string;
  status: string;
  imageUrl?: string;
}

interface BusinessRules {
  startDays?: number[];
  endDays?: number[];
  exceptionKeyword?: string;
  maxDiscount?: number;
}

interface AuditAction {
  action: string;
  targetId: string;
  sku: string | null;
  details: object;
  dataInicio?: Date | string | null;
  dataFim?: Date | string | null;
}

interface DetailedValidationResult {
  isValid: boolean;
  errors: string[];
  autoFilledData?: {
    descricao?: string;
    fornecedor?: string;
  };
}

interface FileUploadData {
  name: string;
  mimeType: string;
  content: string;
}

interface StoreGroupData {
  name: string;
  type: "paste" | "upload";
  data: string | FileUploadData;
}

interface SkuFamily {
  group: string;
  skus: string[];
}

interface SkuFamilyPayload {
  group: string;
  material: string;
}

// =================================================================
// CONTEÚDO DE HELPERS.JS (MIGRADO PARA TYPESCRIPT)
// =================================================================

/**
 * Procura a informação de um produto (SKU) na base de dados de produtos.
 * Implementa um cache para evitar múltiplas leituras da planilha para o mesmo SKU.
 * @param sku O SKU a ser procurado.
 * @returns Um objeto com a informação do produto ou null se não for encontrado.
 * @private
 */
function getProductInfo_(sku: string): ProductInfo | null {
  if (!sku || typeof sku !== "string") return null;
  const trimmedSku = sku.trim();
  const cache = CacheService.getScriptCache();
  const cacheKey = `product_info_${trimmedSku.toLowerCase()}`;
  const cachedInfo = cache.get(cacheKey);

  if (cachedInfo) {
    return JSON.parse(cachedInfo) as ProductInfo;
  }

  const sheet = getSheet_(PRODUCT_INFO_SHEET_NAME);
  if (!sheet) {
    throw new Error(
      `Planilha de informações de produto '${PRODUCT_INFO_SHEET_NAME}' não foi encontrada.`
    );
  }

  const data = sheet.getDataRange().getValues();
  const headers = data.shift()?.map((h) => String(h).trim()) || [];

  const columnIndices = {
    sku: headers.indexOf("COD_PRODUTO"),
    descricao: headers.indexOf("DESC_PRODUTO"),
    categoriaN3: headers.indexOf("DESC_CATN3"),
    categoriaN4: headers.indexOf("DESC_CATN4"),
    fornecedor: headers.indexOf("NOME_FORNECEDOR_REGULAR"),
    status: headers.indexOf("DESC_STATUS"),
    imageUrl: headers.indexOf("IMAGEM_URL"),
  };

  if (columnIndices.sku === -1) {
    throw new Error(
      "Não foi possível encontrar a coluna de SKU na planilha de produtos."
    );
  }

  for (const row of data) {
    const sheetSku = String(row[columnIndices.sku]).trim();
    if (sheetSku.toLowerCase() === trimmedSku.toLowerCase()) {
      const productInfo: ProductInfo = {
        sku: row[columnIndices.sku],
        descricao: row[columnIndices.descricao],
        categoriaN3: row[columnIndices.categoriaN3],
        categoriaN4: row[columnIndices.categoriaN4],
        fornecedor: row[columnIndices.fornecedor],
        status: row[columnIndices.status],
        imageUrl:
          columnIndices.imageUrl > -1 ? row[columnIndices.imageUrl] : undefined,
      };

      cache.put(cacheKey, JSON.stringify(productInfo), 21600); // Cache por 6 horas
      return productInfo;
    }
  }

  return null; // SKU não encontrado
}

/**
 * Valida os dados de uma nova solicitação de promoção com base nas regras de negócio.
 * @param requestData Os dados da solicitação a serem validados.
 * @returns Um objeto DetailedValidationResult.
 * @private
 */
function validateRequestData_(
  requestData: RequestData
): DetailedValidationResult {
  const result: DetailedValidationResult = {
    isValid: true,
    errors: [],
    autoFilledData: {},
  };
  // 1. Validação de SKU (pré-requisito)
  const productInfo = getProductInfo_(requestData.material);
  if (!productInfo) {
    result.errors.push(
      `SKU '${requestData.material}' não encontrado na base de dados de produtos.`
    );
  } else {
    result.autoFilledData.descricao = productInfo.descricao;
    result.autoFilledData.fornecedor = productInfo.fornecedor;
  }

  // 2. Validação de Regras de Negócio
  const dataInicio = parseDate(requestData.dataInicio);
  const dataFim = parseDate(requestData.dataFim);
  const precoDe = Number(requestData.precoDe);
  const precoPor = Number(requestData.precoPor);

  // Validação de Datas
  if (!dataInicio || !dataFim) {
    result.errors.push("As datas de início e fim são obrigatórias.");
  } else if (dataFim < dataInicio) {
    result.errors.push("A data de fim não pode ser anterior à data de início.");
  }

  // Validação de Preços
  if (isNaN(precoDe) || isNaN(precoPor) || precoDe <= 0 || precoPor <= 0) {
    result.errors.push("Os preços 'De' e 'Por' devem ser números positivos.");
  } else if (precoPor > precoDe) {
    result.errors.push("O preço 'Por' não pode ser maior que o preço 'De'.");
  }

  // Conclusão da Validação
  if (result.errors.length > 0) {
    result.isValid = false;
  }

  return result;
}

/**
 * Obtém a planilha correta com base no nome da aba.
 * @param sheetName O nome da aba a ser acessada.
 * @returns O objeto da Planilha Google correta.
 * @private
 */
function getSpreadsheetForSheet_(sheetName: string): Spreadsheet {
  let spreadsheetId: string;
  switch (sheetName) {
    case DB_SHEET_NAME:
    case QUEUE_SHEET_NAME:
      spreadsheetId = DB_PRINCIPAL_SPREADSHEET_ID;
      break;
    case AUDIT_LOG_SHEET_NAME:
    case "log_sistema": // Adicionado para cobrir todos os casos
    case "log_performance":
      spreadsheetId = DB_LOGS_SPREADSHEET_ID;
      break;
    case USER_CONFIG_SHEET_NAME:
    case RULES_CONFIG_SHEET_NAME:
      spreadsheetId = DB_CONFIG_SPREADSHEET_ID;
      break;
    case PRODUCT_INFO_SHEET_NAME:
      spreadsheetId = PRODUCT_INFO_SPREADSHEET_ID;
      break;
    case SKU_FAMILIES_ETNIAS_SHEET_NAME:
    case SKU_FAMILIES_OBSOLETOS_SHEET_NAME:
      spreadsheetId = SKU_FAMILIES_SPREADSHEET_ID;
      break;
    default:
      console.warn(
        `Aba "${sheetName}" não mapeada. Usando a planilha principal por defeito.`
      );
      spreadsheetId = DB_PRINCIPAL_SPREADSHEET_ID;
  }

  if (!spreadsheetId || spreadsheetId.startsWith("COLOQUE_O_ID")) {
    throw new Error(
      `ERRO CRÍTICO: ID da planilha para '${sheetName}' não definido em Config.ts.`
    );
  }

  try {
    // Não é possível armazenar o objeto Spreadsheet diretamente no CacheService.
    // A abordagem de cache em memória por execução (`sCache`) é a correta aqui,
    // pois o objeto Spreadsheet não é serializável.
    // A otimização já foi feita na camada de dados com o cache granular.
    // Vamos manter a lógica original de cache em memória que é válida por execução.
    const sCache: SheetCache = this["spreadsheets"] || {};
    if (!sCache[spreadsheetId]) {
      const perf_startTime = new Date().getTime();
      console.log(
        `PERF: Abrindo planilha pela primeira vez nesta execução: '${sheetName}' (ID: ${spreadsheetId})`
      );
      sCache[spreadsheetId] = SpreadsheetApp.openById(spreadsheetId);
      const perf_endTime = new Date().getTime();
      console.log(
        `PERF: SpreadsheetApp.openById concluído em ${
          perf_endTime - perf_startTime
        }ms`
      );
    }
    this["spreadsheets"] = sCache;
    return sCache[spreadsheetId];
  } catch (e) {
    throw new Error(
      `Falha ao acessar planilha com ID '${spreadsheetId}'. Detalhes: ${
        (e as Error).message
      }`
    );
  }
}

/**
 * Obtém uma aba específica, abstraindo a lógica de qual planilha abrir.
 * @param sheetName O nome da aba desejada.
 * @returns O objeto da aba ou null se não for encontrada.
 */
function getSheet_(sheetName: string): Sheet | null {
  const spreadsheet = getSpreadsheetForSheet_(sheetName);
  return spreadsheet.getSheetByName(sheetName);
}

/**
 * Converte um valor para um objeto Date, retornando null se inválido.
 */
function parseDate(dateValue: any): Date | null {
  if (!dateValue) return null;
  if (dateValue instanceof Date && !isNaN(dateValue.getTime()))
    return dateValue;
  const d = new Date(dateValue);
  return !isNaN(d.valueOf()) ? d : null;
}

/**
 * Formata um valor de data para uma string no formato dd/MM/yyyy.
 * @param dateValue O valor da data a ser formatado.
 * @returns A data formatada ou uma string vazia se a data for inválida.
 */
function formatDateForExport_(dateValue: Date | string): string {
  if (!dateValue) return "";
  const d = new Date(dateValue);
  if (d instanceof Date && !isNaN(d.getTime())) {
    return Utilities.formatDate(d, FUSO_HORARIO_NEGOCIO, "dd/MM/yyyy");
  }
  return String(dateValue);
}

/**
 * Encontra a linha de cabeçalho e os índices de colunas importantes.
 * @param data A matriz de dados da planilha.
 * @returns Um objeto com os dados encontrados ou um erro.
 */
/**
 * Gera um ID único para uma nova solicitação.
 * @returns Uma string de ID única.
 * @private
 */
function generateUniqueId_(): string {
  const timestamp = new Date().getTime();
  const randomPart = Math.random().toString(36).substring(2, 8).toUpperCase();
  return `REQ-${timestamp}-${randomPart}`;
}

function findHeadersAndData_(
  data: any[][],
  keyColumn: string = "ID_ITEM"
): HeadersAndData {
  // Limita a busca do cabeçalho às primeiras 5 linhas para performance e robustez.
  const headerSearchRange = data.slice(0, 5);
  let headerRowIndex = headerSearchRange.findIndex(
    (row) => Array.isArray(row) && row.indexOf(keyColumn) > -1
  );

  if (headerRowIndex === -1) {
    // Se não encontrou nas primeiras 5, podemos opcionalmente procurar em todo o conjunto de dados como fallback.
    headerRowIndex = data.findIndex(
      (row) => Array.isArray(row) && row.indexOf(keyColumn) > -1
    );

    if (headerRowIndex === -1) {
      return {
        error: `Linha de cabeçalho com a coluna chave '${keyColumn}' não encontrada.`,
        data: [],
        headers: [],
        headerRowIndex: -1,
      };
    }
  }

  const headers = data[headerRowIndex].map((h) => String(h));
  const dataRows = data.slice(headerRowIndex + 1);

  return { data: dataRows, headers: headers, headerRowIndex: headerRowIndex };
}

// =================================================================
// CONTEÚDO DE OBSERVABILIDADE.JS (MIGRADO PARA TYPESCRIPT)
// =================================================================

const SYSTEM_LOG_SHEET: string = "log_sistema";
const PERF_LOG_SHEET: string = "log_performance";

const LOG_LEVEL: StringMap = {
  ERROR: "ERROR",
  WARN: "WARN",
  INFO: "INFO",
  DEBUG: "DEBUG",
};

// Server-side default page size for paginated endpoints
const PAGE_SIZE_SERVER: number = 50;

/**
 * Regista uma entrada de log do sistema de forma persistente.
 */
function logSystemEvent(
  level: string,
  functionName: string,
  message: string,
  executionTimeMs: number | null = null
): void {
  try {
    const sheet = getOrCreateSheetByName_(SYSTEM_LOG_SHEET, [
      "Timestamp",
      "Level",
      "FunctionName",
      "Message",
      "UserEmail",
      "ExecutionTimeMs",
    ]);
    const user = Session.getActiveUser()
      ? Session.getActiveUser().getEmail()
      : "SYSTEM";
    sheet.appendRow([
      new Date(),
      level,
      functionName,
      message,
      user,
      executionTimeMs,
    ]);
  } catch (e) {
    console.error(
      `Falha CRÍTICA ao registar log do sistema: ${
        (e as Error).message
      }. Log original: [${level}] ${functionName} - ${message}`
    );
  }
}

/**
 * Envolve uma função para medir sua performance e registar os resultados.
 */
function measurePerformance<T>(functionName: string, fn: () => T): T {
  const startTime = new Date().getTime();
  let result: T;
  let error: Error | null = null;

  try {
    result = fn();
    return result;
  } catch (e) {
    error = e as Error;
    throw e;
  } finally {
    const endTime = new Date().getTime();
    const executionTimeMs = endTime - startTime;
    const user = Session.getActiveUser()
      ? Session.getActiveUser().getEmail()
      : "SYSTEM";

    try {
      const sheet = getOrCreateSheetByName_(PERF_LOG_SHEET, [
        "Timestamp",
        "FunctionName",
        "UserEmail",
        "ExecutionTimeMs",
        "HasError",
      ]);
      sheet.appendRow([
        new Date(),
        functionName,
        user,
        executionTimeMs,
        error !== null,
      ]);
    } catch (e) {
      console.error(
        `Falha ao registar métrica de performance para ${functionName}: ${
          (e as Error).message
        }`
      );
    }

    if (error) {
      logSystemEvent(
        LOG_LEVEL.ERROR,
        functionName,
        `${error.message} | Stack: ${error.stack}`,
        executionTimeMs
      );
    } else {
      console.log(
        `Performance: ${functionName} executou em ${executionTimeMs}ms.`
      );
    }
  }
}

/**
 * Função auxiliar para obter ou criar uma aba de log.
 */
function getOrCreateSheetByName_(sheetName: string, headers: string[]): Sheet {
  let sheet = getSheet_(sheetName);
  if (!sheet) {
    const spreadsheet = getSpreadsheetForSheet_(sheetName);
    sheet = spreadsheet.insertSheet(sheetName);
    sheet.appendRow(headers);
    sheet.setFrozenRows(1);
  }
  return sheet;
}

// =================================================================
// CONTEÚDO DE AUDITORIA.JS (MIGRADO PARA TYPESCRIPT)
// =================================================================

/**
 * Regista uma ação no registo de auditoria imutável.
 */
function logAction_(
  action: string,
  targetId: string,
  sku: string | null,
  details: object,
  dataInicio: any = null,
  dataFim: any = null
): void {
  try {
    const auditSheet = getOrCreateSheetByName_(
      AUDIT_LOG_SHEET_NAME,
      AUDIT_LOG_HEADERS
    );
    const timestamp = new Date();
    const user = Session.getActiveUser().getEmail();
    const detailsString = JSON.stringify(details);

    auditSheet.appendRow([
      timestamp,
      user,
      action,
      targetId,
      sku || "N/A",
      detailsString,
      dataInicio || null,
      dataFim || null,
    ]);
  } catch (e) {
    console.error(
      `Falha CRÍTICA ao registar no registo de auditoria: ${
        (e as Error).message
      }`
    );
  }
}

/**
 * Regista múltiplas ações no registo de auditoria de uma só vez.
 */
function logBulkActions_(actions: AuditAction[]): void {
  if (!actions || actions.length === 0) return;

  try {
    const auditSheet = getOrCreateSheetByName_(
      AUDIT_LOG_SHEET_NAME,
      AUDIT_LOG_HEADERS
    );
    const user = Session.getActiveUser().getEmail();
    const timestamp = new Date();

    const rowsToAppend = actions.map((entry) => {
      const detailsString = JSON.stringify(entry.details);
      return [
        timestamp,
        user,
        entry.action,
        entry.targetId,
        entry.sku || "N/A",
        detailsString,
        entry.dataInicio || null,
        entry.dataFim || null,
      ];
    });

    auditSheet
      .getRange(
        auditSheet.getLastRow() + 1,
        1,
        rowsToAppend.length,
        AUDIT_LOG_HEADERS.length
      )
      .setValues(rowsToAppend);
  } catch (e) {
    console.error(
      `Falha CRÍTICA ao registar ações em massa no registo de auditoria: ${
        (e as Error).message
      }`
    );
  }
}

/**
 * Envia notificações para o utilizador através dos canais configurados.
 */
function sendNotification_(
  recipientEmail: string,
  subject: string,
  htmlBody: string
): void {
  if (!recipientEmail) return;

  const finalRecipient =
    NOTIFICATION_SETTINGS.DEV_NOTIFICATION_EMAIL || recipientEmail;

  if (NOTIFICATION_SETTINGS.EMAIL_ENABLED) {
    try {
      MailApp.sendEmail({
        to: finalRecipient,
        subject: `[${NOTIFICATION_SETTINGS.APP_NAME}] ${subject}`,
        htmlBody: `...`, // O corpo do e-mail permanece o mesmo
      });
    } catch (e) {
      console.error(
        `Falha ao enviar e-mail para ${finalRecipient}: ${(e as Error).message}`
      );
    }
  }

  if (
    NOTIFICATION_SETTINGS.CHAT_ENABLED &&
    NOTIFICATION_SETTINGS.CHAT_WEBHOOK_URL
  ) {
    // A lógica do chat permanece a mesma
  }
}

// =================================================================
// CONTEÚDO DE ADMIN_ACTIONS.JS (MIGRADO PARA TYPESCRIPT)
// =================================================================

function onOpen(): void {
  // A lógica permanece a mesma
}

function showUpdateStatusDialog(): void {
  // A lógica permanece a mesma
}

function showApproveUrgentDialog(): void {
  // A lógica permanece a mesma
}

function approveUrgentItems(idListString: string, justification: string): void {
  // Invalidate the cache whenever urgent items are approved.
  const cache = CacheService.getScriptCache();
  cache.remove("promotion_requests_data");

  // A lógica permanece a mesma, mas com tipagem interna mais forte se necessário
}

function updateItemStatus(idListString: string, newStatus: string): void {
  // Invalidate the cache whenever an item's status is updated.
  const cache = CacheService.getScriptCache();
  cache.remove("promotion_requests_data");

  // A lógica permanece a mesma
}

function resetWorkerState(): void {
  // A lógica permanece a mesma
}

function showReprocessDialog(): void {
  // A lógica permanece a mesma
}

function forceReprocessJob(jobId: string): void {
  // A lógica permanece a mesma
}

function getCompleteUserPermissions_(): PermMap {
  const activeUser = Session.getActiveUser().getEmail();
  if (!activeUser) return {};

  const cache = CacheService.getScriptCache();
  const cacheKey = `user_complete_perms_${activeUser.toLowerCase()}`;
  const cachedPerms = cache.get(cacheKey);
  if (cachedPerms) {
    return JSON.parse(cachedPerms);
  }

  const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
  if (!sheet) {
    // Lança um erro aqui porque a ausência desta planilha é uma falha de configuração crítica.
    throw new Error(
      "A planilha de configuração de usuários não foi encontrada."
    );
  }

  const allSheetData = sheet.getDataRange().getValues();
  const {
    headers,
    data: userData,
    error,
  } = findHeadersAndData_(allSheetData, "EMAIL");

  if (error) {
    // Propaga o erro de `findHeadersAndData_`.
    throw new Error(`Erro ao ler dados de usuários: ${error}`);
  }

  // Validação de Schema: Verifica a presença dos cabeçalhos essenciais.
  const requiredHeaders = ["EMAIL", "ROLE", "PERMISSIONS"];
  for (const header of requiredHeaders) {
    if (headers.indexOf(header) === -1) {
      throw new Error(
        `Cabeçalho '${header}' ausente na planilha de configuração de usuários.`
      );
    }
  }

  const emailIndex = headers.indexOf("EMAIL");
  const roleIndex = headers.indexOf("ROLE");
  const permsIndex = headers.indexOf("PERMISSIONS");

  const userRow = userData.find(
    (row) => String(row[emailIndex]).toLowerCase() === activeUser.toLowerCase()
  );

  if (!userRow) {
    return {}; // Usuário não encontrado, sem permissões.
  }

  const userRole = userRow[roleIndex];
  let granularPerms: PermMap = {};

  // Parse Seguro de JSON para permissões granulares.
  const permsString = userRow[permsIndex];
  if (
    permsString &&
    typeof permsString === "string" &&
    permsString.trim().startsWith("{")
  ) {
    try {
      const parsedPerms = JSON.parse(permsString);
      // Garante que as permissões sejam booleanas.
      for (const key in parsedPerms) {
        granularPerms[key] = String(parsedPerms[key]).toLowerCase() === "true";
      }
    } catch (e) {
      logSystemEvent(
        LOG_LEVEL.WARN,
        "getCompleteUserPermissions_",
        `Falha ao fazer parse do JSON de permissões para o usuário ${activeUser}. Permissões granulares ignoradas. Conteúdo: "${permsString}". Erro: ${
          (e as Error).message
        }`
      );
      // Continua com um objeto de permissões granulares vazio em caso de erro.
    }
  }

  // 1. Lógica de ADMIN: Começa com as permissões base para um admin.
  const finalPerms: PermMap = {};
  if (userRole === USER_ROLES.ADMIN) {
    finalPerms.is_admin = true;
    AVAILABLE_PERMISSIONS.forEach((perm) => {
      finalPerms[perm.id] = true;
    });
  }

  // 2. Mescla as permissões granulares, que podem sobrescrever as de admin se necessário (ex: uma permissão específica negada).
  Object.assign(finalPerms, granularPerms);
  finalPerms.role = userRole;

  // 3. Cache por 1 hora.
  cache.put(cacheKey, JSON.stringify(finalPerms), 3600);
  return finalPerms;
}

function checkPermission_(permission: string): boolean {
  const allPermissions = getCompleteUserPermissions_();
  // Um administrador (is_admin) sempre tem a permissão.
  // Caso contrário, verifica a permissão específica, que já garantimos ser um booleano.
  return (
    allPermissions.is_admin === true || allPermissions[permission] === true
  );
}

function isUserAuthorized_(): boolean {
  const allPermissions = getCompleteUserPermissions_();
  return allPermissions.is_admin === true || allPermissions.is_admin === "true";
}

// =================================================================
// CONTEÚDO DAS APIs (MIGRADO PARA TYPESCRIPT)
// =================================================================

function getUserPermissions(): string {
  return measurePerformance("getUserPermissions", () => {
    const userPerms = getCompleteUserPermissions_();
    const availablePerms = AVAILABLE_PERMISSIONS;

    return JSON.stringify({
      success: true,
      data: {
        userPermissions: userPerms,
        availablePermissions: availablePerms,
      },
    });
  });
}

function getBusinessRules(): string {
  return measurePerformance("getBusinessRules", () => {
    try {
      const sheet = getSheet_(RULES_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error("A planilha de regras de negócio não foi encontrada.");

      const data = sheet.getDataRange().getValues();
      const rules: BusinessRules = {};

      // Converte a lista de chave-valor da planilha num objeto
      data.forEach((row) => {
        const key = row[0];
        let value = row[1];
        if (key === "startDays" || key === "endDays") {
          value = String(value).split(",").map(Number);
        } else if (key === "maxDiscount") {
          value = Number(value);
        }
        (rules as any)[key] = value;
      });

      return JSON.stringify({ success: true, rules: rules });
    } catch (e) {
      return JSON.stringify({ success: false, message: e.message });
    }
  });
}

function getUserDetails(email: string): string {
  return measurePerformance("getUserDetails", () => {
    try {
      if (!checkPermission_("can_manage_users")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para ver detalhes de usuários."
        );
      }

      const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error(
          "A planilha de configuração de usuários não foi encontrada."
        );

      const data = sheet.getDataRange().getValues();
      const headers = data[0];
      const emailColumn = headers.indexOf("EMAIL");

      if (emailColumn === -1) {
        throw new Error(
          "Coluna 'EMAIL' não encontrada na planilha de usuários."
        );
      }

      const userRow = data.find((row) => row[emailColumn] === email);

      if (!userRow) {
        return JSON.stringify({
          success: false,
          message: `Usuário com email '${email}' não encontrado.`,
        });
      }

      const user: any = {};
      headers.forEach((header, i) => {
        const key = header.toLowerCase();
        if (
          key === "permissions" &&
          typeof userRow[i] === "string" &&
          userRow[i].startsWith("{")
        ) {
          try {
            user[key] = JSON.parse(userRow[i]);
          } catch (e) {
            user[key] = {}; // Fallback
          }
        } else {
          user[key] = userRow[i];
        }
      });

      return JSON.stringify({ success: true, user: user });
    } catch (e) {
      return JSON.stringify({ success: false, message: e.message });
    }
  });
}

function getRequestsImportTemplate(): string {
  // Card 2: Unifica o esquema de dados. O template deve refletir os campos essenciais para a criação.
  const headers = [
    "MATERIAL", // Obrigatório
    "DE (R$)", // Obrigatório
    "POR (R$)", // Obrigatório
    "DATA INÍCIO", // Obrigatório
    "DATA FIM", // Obrigatório
    "OBSERVAÇÃO COMERCIAL", // Opcional
  ];
  // Adiciona o BOM para garantir a codificação UTF-8 correta no Excel.
  const csvContent = "\uFEFF" + headers.join(",");
  const fileName = "template_importacao_solicitacoes.csv";
  return JSON.stringify({
    success: true,
    csvData: csvContent,
    fileName: fileName,
  });
}

function importNewRequests(fileContent: string): string {
  return measurePerformance("importNewRequests", () => {
    if (!checkPermission_("can_create_requests")) {
      return JSON.stringify({
        success: false,
        message:
          "Acesso negado. Você não tem permissão para criar solicitações.",
      });
    }

    const lock = LockService.getScriptLock();
    try {
      lock.waitLock(30000);

      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet)
        throw new Error("A planilha de banco de dados não foi encontrada.");

      // Remove o BOM se ele existir para evitar problemas com o parser.
      if (fileContent.startsWith("\uFEFF")) {
        fileContent = fileContent.substring(1);
      }

      const csvRows = Utilities.parseCsv(fileContent);
      if (csvRows.length < 2)
        throw new Error(
          "O arquivo CSV está vazio ou contém apenas o cabeçalho."
        );

      const csvHeader = csvRows.shift().map((h) => h.trim());
      // Card 2: Unifica o esquema de dados. Valida contra o novo template.
      const requiredHeaders = [
        "MATERIAL",
        "DE (R$)",
        "POR (R$)",
        "DATA INÍCIO",
        "DATA FIM",
      ];
      if (!requiredHeaders.every((h) => csvHeader.includes(h))) {
        throw new Error(
          "O cabeçalho do arquivo é inválido. Faça o download do template mais recente."
        );
      }

      const validationResults = { valid: [], invalid: [] };
      const rowsToInsert = [];
      const actionsToLog: AuditAction[] = [];
      const currentUser = Session.getActiveUser().getEmail();
      const timestamp = new Date();

      // Mapeia os índices de forma segura.
      const matIndex = csvHeader.indexOf("MATERIAL");
      const deIndex = csvHeader.indexOf("DE (R$)");
      const porIndex = csvHeader.indexOf("POR (R$)");
      const inicioIndex = csvHeader.indexOf("DATA INÍCIO");
      const fimIndex = csvHeader.indexOf("DATA FIM");
      const obsIndex = csvHeader.indexOf("OBSERVAÇÃO COMERCIAL"); // Alinhado com o DB_COLUMN_ORDER

      csvRows.forEach((row, index) => {
        const requestData: RequestData = {
          material: row[matIndex],
          precoDe: parseFloat(String(row[deIndex]).replace(",", ".")),
          precoPor: parseFloat(String(row[porIndex]).replace(",", ".")),
          dataInicio: row[inicioIndex],
          dataFim: row[fimIndex],
          obsComercial: obsIndex > -1 ? row[obsIndex] || "" : "", // Campo opcional
          // Preenche valores padrão para os campos não presentes no CSV
          descricao: "",
          fornecedor: "",
          bandeira: "",
          loja: "",
          descPercent: "",
          recompMargem: "",
          valorRebate: "",
          nRebaixa: "",
          nAcao: "",
        };

        const validation = validateRequestData_(requestData);

        if (validation.isValid) {
          const newItemId = `REQ-${timestamp.getTime()}-${index}`;
          const finalData = { ...requestData, ...validation.autoFilledData };

          const newRow = DB_COLUMN_ORDER.map((header) => {
            switch (header) {
              case "ID_ITEM":
                return newItemId;
              case "STATUS_GERAL":
                return STATUS_GERAL.PENDENTE_SAP;
              case "SOLICITANTE":
                return currentUser;
              case "DATA/HORA 1ª SUBMISSAO":
                return timestamp;
              case "MATERIAL":
                return finalData.material;
              case "DESCRIÇÃO":
                return finalData.descricao;
              case "FORNECEDOR":
                return finalData.fornecedor;
              case "DE (R$)":
                return finalData.precoDe;
              case "POR (R$)":
                return finalData.precoPor;
              case "DATA INÍCIO":
                return parseDate(finalData.dataInicio);
              case "DATA FIM":
                return parseDate(finalData.dataFim);
              case "OBSERVAÇÃO COMERCIAL":
                return finalData.obsComercial;
              default:
                return "";
            }
          });

          rowsToInsert.push(newRow);
          validationResults.valid.push({
            originalRow: index + 2,
            data: finalData,
          });
          actionsToLog.push({
            action: "BULK_CREATE_REQUEST",
            targetId: newItemId,
            sku: finalData.material,
            details: finalData,
            dataInicio: parseDate(finalData.dataInicio),
            dataFim: parseDate(finalData.dataFim),
          });
        } else {
          validationResults.invalid.push({
            originalRow: index + 2,
            data: requestData,
            errors: validation.errors,
          });
        }
      });

      if (rowsToInsert.length > 0) {
        sheet
          .getRange(
            sheet.getLastRow() + 1,
            1,
            rowsToInsert.length,
            DB_COLUMN_ORDER.length
          )
          .setValues(rowsToInsert);
        logBulkActions_(actionsToLog);
      }

      return JSON.stringify({
        success: true,
        message: `Importação concluída. ${validationResults.valid.length} solicitações criadas, ${validationResults.invalid.length} falharam.`,
        validationResults: validationResults,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha na importação: ${(e as Error).message}`,
      });
    } finally {
      lock.releaseLock();
    }
  });
}

function removeUser(email: string): string {
  return measurePerformance("removeUser", () => {
    try {
      if (!checkPermission_("can_manage_users")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para remover usuários."
        );
      }

      const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error(
          "A planilha de configuração de usuários não foi encontrada."
        );

      const data = sheet.getDataRange().getValues();
      const emailColumn = data[0].indexOf("EMAIL");
      if (emailColumn === -1)
        throw new Error(
          "Coluna 'EMAIL' não encontrada na planilha de usuários."
        );

      const rowIndex = data.findIndex((row) => row[emailColumn] === email);
      if (rowIndex === -1)
        throw new Error(`Usuário ${email} não encontrado para remoção.`);

      sheet.deleteRow(rowIndex + 1);

      CacheService.getScriptCache().removeAll([
        `user_perms_${email.toLowerCase()}`,
        `user_complete_perms_${email.toLowerCase()}`,
      ]);
      return JSON.stringify({
        success: true,
        message: `Usuário ${email} removido com sucesso.`,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao remover usuário: ${(e as Error).message}`,
      });
    }
  });
}

function importDecisions(fileContent: string): string {
  return measurePerformance("importDecisions", () => {
    if (!checkPermission_("can_approve_requests")) {
      return JSON.stringify({
        success: false,
        message:
          "Acesso negado. Você não tem permissão para importar decisões.",
      });
    }

    const lock = LockService.getScriptLock();
    try {
      lock.waitLock(30000); // Aguarda o bloqueio por 30 segundos

      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet)
        throw new Error("A planilha de banco de dados não foi encontrada.");

      const csvRows = Utilities.parseCsv(fileContent);
      if (csvRows.length < 2)
        throw new Error(
          "O arquivo CSV está vazio ou contém apenas o cabeçalho."
        );

      const csvHeader = csvRows.shift().map((h) => h.trim());
      const idIndex = csvHeader.indexOf("ID_ITEM");
      const statusIndex = csvHeader.indexOf("NOVO_STATUS");
      const reasonIndex = csvHeader.indexOf("MOTIVO_RECUSA");

      if (idIndex === -1 || statusIndex === -1) {
        throw new Error(
          "Cabeçalho inválido. Verifique se as colunas 'ID_ITEM' e 'NOVO_STATUS' existem."
        );
      }

      const allSheetData = sheet.getDataRange().getValues();
      const {
        headers: sheetHeaders,
        data: sheetData,
        error,
        headerRowIndex,
      } = findHeadersAndData_(allSheetData);
      if (error) throw new Error(`Erro ao processar planilha: ${error}`);

      const sheetIdCol = sheetHeaders.indexOf("ID_ITEM");
      const sheetStatusCol = sheetHeaders.indexOf("STATUS_GERAL");
      const sheetReasonCol = sheetHeaders.indexOf("MOTIVO_RECUSA");
      const materialCol = sheetHeaders.indexOf("MATERIAL");

      if (sheetIdCol === -1 || sheetStatusCol === -1 || sheetReasonCol === -1) {
        throw new Error(
          "Colunas essenciais (ID_ITEM, STATUS_GERAL, MOTIVO_RECUSA) não encontradas na planilha."
        );
      }

      const validStatuses = [
        "CADASTRO EFETUADO",
        "RECUSADO",
        "AJUSTE NECESSÁRIO",
      ];
      const errors = [];
      const actionsToLog: AuditAction[] = [];
      let succeeded = 0;
      let changesMade = false;

      // Mapeia os dados da planilha por ID para busca rápida
      const dataMap = new Map(
        sheetData.map((row, i) => [String(row[sheetIdCol]), { row, index: i }])
      );

      csvRows.forEach((row, index) => {
        const itemId = row[idIndex];
        const newStatus = row[statusIndex]
          ? row[statusIndex].trim().toUpperCase()
          : "";
        const reason = row[reasonIndex] ? row[reasonIndex].trim() : "";

        if (!itemId || !newStatus) return;

        if (!validStatuses.includes(newStatus)) {
          errors.push({
            row: index + 2,
            id: itemId,
            error: `Status '${newStatus}' inválido.`,
          });
          return;
        }

        const target = dataMap.get(String(itemId));
        if (!target) {
          errors.push({
            row: index + 2,
            id: itemId,
            error: "ID_ITEM não encontrado na base de dados.",
          });
          return;
        }

        // Atualiza os dados no array de dados em memória
        sheetData[target.index][sheetStatusCol] = newStatus;
        if (newStatus === "RECUSADO" && reason) {
          sheetData[target.index][sheetReasonCol] = reason;
        }
        changesMade = true;

        actionsToLog.push({
          action: "IMPORT_DECISION",
          targetId: itemId,
          sku: sheetData[target.index][materialCol],
          details: { newStatus, reason },
        });
        succeeded++;
      });

      if (changesMade) {
        // Escreve de volta apenas os dados, no local correto
        const dataRange = sheet.getRange(
          headerRowIndex + 2,
          1,
          sheetData.length,
          sheetHeaders.length
        );
        dataRange.setValues(sheetData);
        logBulkActions_(actionsToLog);
      }

      return JSON.stringify({
        success: true,
        processed: csvRows.length,
        succeeded: succeeded,
        failed: errors.length,
        errors: errors,
        message: `Importação concluída. ${succeeded} registros atualizados, ${errors.length} falharam.`,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha na importação: ${(e as Error).message}`,
        errors: [],
      });
    } finally {
      lock.releaseLock();
    }
  });
}

function exportPendingRequests(): string {
  return measurePerformance("exportPendingRequests", () => {
    try {
      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet) throw new Error("Database sheet not found.");

      const allRawData = sheet.getDataRange().getValues();
      const { headers, data: allData, error } = findHeadersAndData_(allRawData);
      if (error)
        throw new Error(`Erro ao processar planilha para exportação: ${error}`);

      const statusIndex = headers.indexOf("STATUS_GERAL");
      const pendingStatuses = ["PENDENTE DE CADASTRO SAP", "AJUSTE NECESSÁRIO"];

      const pendingRows = allData.filter((row) =>
        pendingStatuses.includes(String(row[statusIndex]).toUpperCase())
      );

      if (pendingRows.length === 0) {
        return JSON.stringify({
          success: false,
          message: "Nenhuma solicitação pendente para exportar.",
        });
      }

      // BE-02: Unificar esquema. Usa as colunas da base de dados como a fonte da verdade.
      // Mantém todas as colunas originais para dar contexto completo ao decisor.
      const exportHeaders = [
        ...DB_COLUMN_ORDER,
        "NOVO_STATUS", // Coluna para o usuário preencher a decisão
        "MOTIVO_RECUSA", // Coluna para o usuário preencher o motivo
      ];

      // Cria um mapa do cabeçalho para o índice para uma busca robusta
      const headerIndexMap = new Map(headers.map((h, i) => [h, i]));

      const csvRows = pendingRows.map((row) => {
        // Mapeia os dados da linha de acordo com a ordem de DB_COLUMN_ORDER
        const orderedRow = DB_COLUMN_ORDER.map((colName) => {
          const index = headerIndexMap.get(colName);
          if (index === undefined) return ""; // Coluna não encontrada na aba, retorna vazio

          let value = row[index];
          // Formata as datas para exportação
          if (
            [
              "DATA INÍCIO",
              "DATA FIM",
              "DATA/HORA 1ª SUBMISSAO",
              "DATA/HORA RESPOSTA",
              "DATA/HORA ULTIMO AJUSTE",
            ].includes(colName)
          ) {
            value = formatDateForExport_(value);
          }
          // Garante que valores com vírgula ou aspas sejam encapsulados
          return `"${String(value || "").replace(/"/g, '""')}"`;
        });

        // Adiciona as colunas de decisão vazias
        orderedRow.push('""'); // NOVO_STATUS
        orderedRow.push('""'); // MOTIVO_RECUSA

        return orderedRow.join(",");
      });

      // Adiciona o BOM e os cabeçalhos
      // BE-03 Fix: Garante que o BOM seja adicionado apenas uma vez e que a junção esteja correta.
      const csvContent =
        "\uFEFF" + exportHeaders.join(",") + "\n" + csvRows.join("\n");
      const fileName = `decisoes_pendentes_${Utilities.formatDate(
        new Date(),
        "GMT-3",
        "yyyyMMdd_HHmmss"
      )}.csv`;

      return JSON.stringify({
        success: true,
        csvData: csvContent,
        fileName: fileName,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao exportar: ${(e as Error).message}`,
      });
    }
  });
}

function getStoreGroupDetails(groupName: string): string {
  return measurePerformance("getStoreGroupDetails", () => {
    try {
      // Card 2: Acessa a planilha de "Grupos de Lojas" diretamente pelo ID.
      const spreadsheet = SpreadsheetApp.openById(
        DB_STORE_GROUPS_SPREADSHEET_ID
      );
      if (!spreadsheet) {
        throw new Error(
          "A planilha de Grupos de Lojas não foi encontrada ou o ID está incorreto."
        );
      }

      const sheet = spreadsheet.getSheetByName(groupName);
      if (!sheet) {
        // Fornece uma mensagem de erro mais clara.
        throw new Error(
          `O grupo de lojas '${groupName}' não foi encontrado. Verifique se existe uma aba com esse nome exato na planilha 'Grupos de Lojas'.`
        );
      }

      // Lê apenas a primeira coluna para otimização
      const data = sheet.getRange("A:A").getValues();
      // Assume que as lojas estão na primeira coluna e filtra valores vazios.
      const stores = data
        .map((row) => row[0])
        .filter((store) => store && String(store).trim() !== "");

      return JSON.stringify({ success: true, stores: stores });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao carregar detalhes do grupo: ${(e as Error).message}`,
      });
    }
  });
}

function deleteStoreGroup(groupName: string): string {
  return measurePerformance("deleteStoreGroup", () => {
    try {
      if (!checkPermission_("can_manage_store_groups")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para excluir grupos de lojas."
        );
      }

      const spreadsheet = SpreadsheetApp.openById(
        DB_STORE_GROUPS_SPREADSHEET_ID
      );
      const sheet = spreadsheet.getSheetByName(groupName);

      if (!sheet) {
        return JSON.stringify({
          success: false,
          message: "Grupo não encontrado.",
        });
      }

      spreadsheet.deleteSheet(sheet);

      return JSON.stringify({
        success: true,
        message: `Grupo '${groupName}' foi removido.`,
      });
    } catch (e) {
      return JSON.stringify({ success: false, message: (e as Error).message });
    }
  });
}

function saveBusinessRules(rules: BusinessRules): string {
  return measurePerformance("saveBusinessRules", () => {
    try {
      const sheet = getSheet_(RULES_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error("A planilha de regras de negócio não foi encontrada.");

      const rulesArray = Object.keys(rules).map((key) => {
        let value = (rules as any)[key];
        if (Array.isArray(value)) {
          value = value.join(",");
        }
        return [key, value];
      });

      sheet.clearContents();
      sheet.getRange(1, 1, rulesArray.length, 2).setValues(rulesArray);

      return JSON.stringify({
        success: true,
        message: "Regras de negócio salvas com sucesso!",
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao salvar regras: ${e.message}`,
      });
    }
  });
}

function saveStoreGroup(groupData: StoreGroupData): string {
  return measurePerformance("saveStoreGroup", () => {
    try {
      if (!checkPermission_("can_manage_store_groups")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para gerir grupos de lojas."
        );
      }
      const spreadsheet = SpreadsheetApp.openById(
        DB_STORE_GROUPS_SPREADSHEET_ID
      );
      if (!spreadsheet)
        throw new Error(
          "A planilha de Grupos de Lojas não foi encontrada ou o ID está incorreto."
        );

      let groupSheet = spreadsheet.getSheetByName(groupData.name);
      if (groupSheet) {
        groupSheet.clear();
      } else {
        groupSheet = spreadsheet.insertSheet(groupData.name);
      }

      let storeList: string[][];
      if (groupData.type === "paste") {
        storeList = groupData.data
          .toString()
          .split("\n")
          .map((s) => [s.trim()])
          .filter((row) => row[0] !== "");
      } else {
        throw new Error(
          "O upload de ficheiros para grupos de lojas ainda não foi implementado."
        );
      }

      if (storeList.length > 0) {
        groupSheet.getRange(1, 1, storeList.length, 1).setValues(storeList);
      }

      return JSON.stringify({
        success: true,
        message: `Grupo '${groupData.name}' salvo com sucesso.`,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao salvar grupo de lojas: ${(e as Error).message}`,
      });
    }
  });
}

function getStoreGroups(): string {
  return measurePerformance("getStoreGroups", () => {
    try {
      const spreadsheet = SpreadsheetApp.openById(
        DB_STORE_GROUPS_SPREADSHEET_ID
      );
      if (!spreadsheet)
        throw new Error(
          "A planilha de Grupos de Lojas não foi encontrada ou o ID está incorreto."
        );

      const sheets = spreadsheet.getSheets();

      // Filtra para não incluir abas de sistema como 'template'
      const groupNames = sheets
        .map((sheet) => sheet.getName())
        .filter((name) => name.toLowerCase() !== "template");

      return JSON.stringify({ success: true, groups: groupNames });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao carregar grupos de lojas: ${e.message}`,
      });
    }
  });
}

function getUsers(): string {
  return measurePerformance("getUsers", () => {
    try {
      const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error(
          "A planilha de configuração de usuários não foi encontrada."
        );

      const data = sheet.getDataRange().getValues();
      const headers = data.shift() || [];
      const users = data.map((row) => {
        const user: any = {};
        headers.forEach((header, i) => {
          const key = header.toLowerCase();
          if (
            key === "permissions" &&
            typeof row[i] === "string" &&
            row[i].startsWith("{")
          ) {
            try {
              user[key] = JSON.parse(row[i]);
            } catch (e) {
              user[key] = {}; // Fallback to empty object on parse error
            }
          } else {
            user[key] = row[i];
          }
        });
        return user;
      });

      return JSON.stringify({ success: true, users: users });
    } catch (e) {
      return JSON.stringify({ success: false, message: e.message });
    }
  });
}

function addUser(userData: User): string {
  return measurePerformance("addUser", () => {
    try {
      if (!checkPermission_("can_manage_users")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para adicionar usuários."
        );
      }
      const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error(
          "A planilha de configuração de usuários não foi encontrada."
        );

      const data = sheet.getDataRange().getValues();
      const headers = data[0];
      const emailColumn = headers.indexOf("EMAIL");

      if (data.slice(1).some((row) => row[emailColumn] === userData.email)) {
        throw new Error(`O usuário com o email '${userData.email}' já existe.`);
      }

      const roleColumn = headers.indexOf("ROLE");
      const permissionsColumn = headers.indexOf("PERMISSIONS");

      const newRow = [];
      newRow[emailColumn] = userData.email;
      newRow[roleColumn] = userData.role;
      newRow[permissionsColumn] = JSON.stringify(userData.permissions || {});

      sheet.appendRow(newRow);
      CacheService.getScriptCache().removeAll([
        `user_perms_${userData.email.toLowerCase()}`,
        `user_complete_perms_${userData.email.toLowerCase()}`,
      ]);
      return JSON.stringify({
        success: true,
        message: `Usuário ${userData.email} adicionado com sucesso.`,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao adicionar usuário: ${(e as Error).message}`,
      });
    }
  });
}

function updateUser(userData: User): string {
  return measurePerformance("updateUser", () => {
    try {
      if (!checkPermission_("can_manage_users")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para atualizar usuários."
        );
      }
      const sheet = getSheet_(USER_CONFIG_SHEET_NAME);
      if (!sheet)
        throw new Error(
          "A planilha de configuração de usuários não foi encontrada."
        );

      const data = sheet.getDataRange().getValues();
      const headers = data[0];
      const emailColumn = headers.indexOf("EMAIL");
      const roleColumn = headers.indexOf("ROLE");
      const permissionsColumn = headers.indexOf("PERMISSIONS");

      const rowIndex = data.findIndex(
        (row) => row[emailColumn] === userData.email
      );
      if (rowIndex === -1)
        throw new Error(
          `Usuário ${userData.email} não encontrado para atualização.`
        );

      // +1 for 1-based sheet range index
      const sheetRowIndex = rowIndex + 1;
      sheet.getRange(sheetRowIndex, roleColumn + 1).setValue(userData.role);
      sheet
        .getRange(sheetRowIndex, permissionsColumn + 1)
        .setValue(JSON.stringify(userData.permissions || {}));

      CacheService.getScriptCache().removeAll([
        `user_perms_${userData.email.toLowerCase()}`,
        `user_complete_perms_${userData.email.toLowerCase()}`,
      ]);
      return JSON.stringify({
        success: true,
        message: `Usuário ${userData.email} atualizado com sucesso.`,
      });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao atualizar usuário: ${(e as Error).message}`,
      });
    }
  });
}

function getSkuFamilies(): string {
  return measurePerformance("getSkuFamilies", () => {
    try {
      const sheets = [
        getSheet_(SKU_FAMILIES_ETNIAS_SHEET_NAME),
        getSheet_(SKU_FAMILIES_OBSOLETOS_SHEET_NAME),
      ];

      const allFamilies: { [group: string]: string[] } = {};

      sheets.forEach((sheet) => {
        if (sheet) {
          const allSheetData = sheet.getDataRange().getValues();
          const { headers, data, error } = findHeadersAndData_(
            allSheetData,
            "id_grupo"
          );

          if (error) {
            console.warn(
              `Não foi possível processar a aba ${sheet.getName()}: ${error}`
            );
            return;
          }

          const groupIndex = headers.indexOf("id_grupo");
          const materialIndex = headers.indexOf("sku");

          if (groupIndex === -1 || materialIndex === -1) {
            console.warn(
              `Cabeçalhos 'id_grupo' ou 'sku' não encontrados na aba '${sheet.getName()}'.`
            );
            return;
          }

          data.forEach((row) => {
            const group = row[groupIndex];
            const material = row[materialIndex];
            if (group && material) {
              if (!allFamilies[group]) {
                allFamilies[group] = [];
              }
              allFamilies[group].push(material);
            }
          });
        }
      });

      const result: SkuFamily[] = Object.keys(allFamilies)
        .map((group) => ({
          group: group,
          skus: allFamilies[group],
        }))
        .sort((a, b) => a.group.localeCompare(b.group));

      return JSON.stringify({ success: true, families: result });
    } catch (e) {
      return JSON.stringify({
        success: false,
        message: `Falha ao carregar famílias SKU: ${(e as Error).message}`,
      });
    }
  });
}

function addSkuToFamily(payload: SkuFamilyPayload): string {
  return measurePerformance("addSkuToFamily", () => {
    try {
      const userPerms = getCompleteUserPermissions_();
      const canCreate =
        userPerms.role === USER_ROLES.ANALYST ||
        userPerms.can_manage_sku_families;
      if (!canCreate) {
        throw new Error(
          "Acesso negado. Você não tem permissão para criar ou editar famílias SKU."
        );
      }

      const familiesResponse = JSON.parse(getSkuFamilies());
      if (!familiesResponse.success) {
        throw new Error(
          "Não foi possível verificar as famílias de SKU existentes para evitar duplicados."
        );
      }
      const existingGroups: SkuFamily[] = familiesResponse.families || [];

      let groupNameToUse = payload.group;
      const groupExists = existingGroups.some(
        (family) => family.group === payload.group
      );

      if (!groupExists) {
        groupNameToUse = `FAM-${new Date().getTime()}`;
        Logger.log(
          `O grupo '${payload.group}' não foi encontrado. A criar novo grupo com ID gerado automaticamente: '${groupNameToUse}'.`
        );
      }

      const sheetName = payload.group.toUpperCase().includes("ETNIA")
        ? SKU_FAMILIES_ETNIAS_SHEET_NAME
        : SKU_FAMILIES_OBSOLETOS_SHEET_NAME;

      const sheet = getSheet_(sheetName);
      if (!sheet)
        throw new Error(
          `A planilha '${sheetName}' para famílias SKU não foi encontrada.`
        );

      sheet.appendRow([groupNameToUse, payload.material]);

      return JSON.stringify({
        success: true,
        message: `SKU ${payload.material} adicionado ao grupo ${groupNameToUse}.`,
      });
    } catch (e) {
      return JSON.stringify({ success: false, message: (e as Error).message });
    }
  });
}

function removeSkuFromFamily(payload: SkuFamilyPayload): string {
  return measurePerformance("removeSkuFromFamily", () => {
    try {
      if (!checkPermission_("can_manage_sku_families")) {
        throw new Error(
          "Acesso negado. Você não tem permissão para remover SKUs de famílias."
        );
      }

      const sheetName = payload.group.toUpperCase().includes("ETNIA")
        ? SKU_FAMILIES_ETNIAS_SHEET_NAME
        : SKU_FAMILIES_OBSOLETOS_SHEET_NAME;
      const sheet = getSheet_(sheetName);
      if (!sheet)
        throw new Error(`A planilha '${sheetName}' não foi encontrada.`);

      const data = sheet.getDataRange().getValues();
      let rowDeleted = false;
      for (let i = data.length - 1; i >= 0; i--) {
        if (data[i][0] === payload.group && data[i][1] === payload.material) {
          sheet.deleteRow(i + 1);
          rowDeleted = true;
          break;
        }
      }

      if (!rowDeleted) {
        throw new Error(
          `SKU ${payload.material} não encontrado no grupo ${payload.group}.`
        );
      }

      return JSON.stringify({
        success: true,
        message: `SKU ${payload.material} removido do grupo ${payload.group}.`,
      });
    } catch (e) {
      return JSON.stringify({ success: false, message: (e as Error).message });
    }
  });
}

// =================================================================
// CONTEÚDO DO PROCESSADOR.JS (MIGRADO PARA TYPESCRIPT)
// =================================================================

/**
 * Gera uma chave de cache determinística a partir de um objeto de filtros.
 * @param filters O objeto de filtros da UI.
 * @returns Uma string de chave de cache segura.
 */
function generateCacheKeyFromFilters_(filters: any): string {
  if (!filters || Object.keys(filters).length === 0) {
    return "promotions_all_items";
  }
  // Cria uma chave estável ordenando as propriedades do filtro
  const keyParts = Object.keys(filters)
    .sort()
    .map((key) => {
      return `${key}:${filters[key]}`;
    });
  const keyString = `promotions_filter_${keyParts.join("_")}`;

  // O CacheService tem um limite de 250 caracteres para chaves.
  // Se a chave for muito longa, usamos um hash para garantir que ela se encaixe.
  if (keyString.length > 250) {
    const hash = Utilities.computeDigest(
      Utilities.DigestAlgorithm.SHA_256,
      keyString
    );
    return `promotions_hash_${Utilities.base64Encode(hash)}`;
  }
  return keyString;
}

function getPromotionRequests(filters: any): string {
  return measurePerformance("getPromotionRequests", () => {
    try {
      const cache = CacheService.getScriptCache();
      const dynamicCacheKey = generateCacheKeyFromFilters_(filters);

      // TODO: Esta é uma solução temporária para diferenciar chamadas da UI de chamadas de exportação.
      // A longo prazo, o frontend deve enviar explicitamente um parâmetro 'fetchAll: true' para obter todos os dados.
      const fetchAll = filters.fetchAll === true;

      const cachedData = cache.get(dynamicCacheKey);
      if (cachedData) {
        console.log(`PERF: Cache HIT para a chave: ${dynamicCacheKey}`);
        return cachedData;
      }

      console.log(
        `PERF: Cache MISS para a chave: ${dynamicCacheKey}. A processar dados.`
      );
      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet) throw new Error("Database sheet not found.");

      // === INÍCIO DA OTIMIZAÇÃO COM CHUNKING ===
      const lastRow = sheet.getLastRow();
      const lastColumn = sheet.getLastColumn();
      console.log(
        `DIAGNÓSTICO: A planilha '${DB_SHEET_NAME}' tem ${lastRow} linhas.`
      );

      // Otimização: ler apenas o início da planilha para encontrar o cabeçalho
      const headerSearchRangeData = sheet
        .getRange(1, 1, Math.min(5, lastRow), lastColumn)
        .getValues();
      const headerInfo = findHeadersAndData_(headerSearchRangeData);
      if (headerInfo.error) throw new Error(headerInfo.error);

      const headers = headerInfo.headers;
      // A primeira linha de dados reais começa após a linha do cabeçalho
      let startRow = headerInfo.headerRowIndex + 2;

      const chunkSize = 500;
      const filteredRows: any[][] = [];

      const materialIndex = headers.indexOf("MATERIAL");
      const descIndex = headers.indexOf("DESCRIÇÃO");
      const solicitanteIndex = headers.indexOf("SOLICITANTE");
      const statusIndex = headers.indexOf("STATUS_GERAL");

      const term = filters.searchTerm
        ? String(filters.searchTerm).toLowerCase()
        : null;
      const statusFilter =
        filters.statusFilter && filters.statusFilter !== "ALL"
          ? String(filters.statusFilter).toUpperCase()
          : null;

      const pageSize = PAGE_SIZE_SERVER || 50;
      const pageNumber =
        filters && filters.pageNumber ? Number(filters.pageNumber) : 1;
      const requiredItems = pageNumber * pageSize;

      const startTime = new Date().getTime();
      let processedRowCount = 0;

      while (startRow <= lastRow) {
        const remainingRows = lastRow - startRow + 1;
        const currentChunkSize = Math.min(chunkSize, remainingRows);
        if (currentChunkSize <= 0) break;

        const range = sheet.getRange(startRow, 1, currentChunkSize, lastColumn);
        const chunkData = range.getValues();
        processedRowCount += chunkData.length;

        const chunkFilteredRows = chunkData.filter((row) => {
          let matches = true;
          if (statusFilter) {
            matches =
              String(row[statusIndex] || "").toUpperCase() === statusFilter;
          }
          if (matches && term) {
            const inMaterial =
              materialIndex > -1
                ? String(row[materialIndex] || "")
                    .toLowerCase()
                    .includes(term)
                : false;
            const inDesc =
              descIndex > -1
                ? String(row[descIndex] || "")
                    .toLowerCase()
                    .includes(term)
                : false;
            const inSolicitante =
              solicitanteIndex > -1
                ? String(row[solicitanteIndex] || "")
                    .toLowerCase()
                    .includes(term)
                : false;
            matches = inMaterial || inDesc || inSolicitante;
          }
          return matches;
        });

        filteredRows.push(...chunkFilteredRows);

        // Se não for para buscar tudo (UI mode) e já temos itens suficientes para a página atual, paramos.
        if (!fetchAll && filteredRows.length >= requiredItems) {
          break;
        }

        startRow += chunkSize;
      }
      const endTime = new Date().getTime();
      console.log(
        `DIAGNÓSTICO: A filtragem de ${processedRowCount} linhas em chunks demorou ${
          endTime - startTime
        }ms.`
      );

      // TODO: A paginação e ordenação final ainda ocorrem em memória.
      // Para otimizar mais, a filtragem e ordenação deveriam ocorrer no lado do "servidor" (e.g., Google Sheets Query)
      // antes de trazer os dados para o script, especialmente para buscar promoções mais antigas que ficariam em páginas finais.

      const totalRecords = filteredRows.length;
      // Em modo UI, não sabemos o total real, então o total de páginas cresce à medida que o usuário avança.
      // Em modo 'fetchAll', calculamos o total real.
      const totalPages = fetchAll
        ? Math.max(1, Math.ceil(totalRecords / pageSize))
        : Math.max(pageNumber, Math.ceil(totalRecords / pageSize));
      const pagestart = (pageNumber - 1) * pageSize;

      const pagedResults = filteredRows
        .slice(pagestart, pagestart + pageSize)
        .map((row) => {
          const item: any = {};
          headers.forEach((h, i) => (item[h] = row[i]));
          if (materialIndex > -1) {
            const sku = row[materialIndex];
            if (sku) {
              const productInfo = getProductInfo_(sku);
              item.imageUrl = productInfo ? productInfo.imageUrl : null;
            }
          }
          return item;
        });

      const response = {
        requests: pagedResults,
        totalRecords: totalRecords, // Note: In UI mode, this is the total *found so far*.
        totalPages: totalPages,
      };

      const responseString = JSON.stringify(response);
      // Apenas faz cache se a busca foi completa, para não cachear resultados parciais da UI.
      if (fetchAll) {
        cache.put(dynamicCacheKey, responseString, 900); // Cache por 15 minutos
      }

      return responseString;
    } catch (e) {
      console.error("Erro em getPromotionRequests: " + (e as Error).message);
      return JSON.stringify({
        success: false,
        error: (e as Error).message,
      });
    }
  });
}

function createNewRequest(requestData: RequestData): string {
  return measurePerformance("createNewRequest", () => {
    // Validação inicial fora do bloqueio para performance
    const validationResult = validateRequestData_(requestData);
    if (!validationResult.isValid) {
      return JSON.stringify({
        success: false,
        message: `Dados inválidos: ${validationResult.errors.join(", ")}`,
        errors: validationResult.errors,
      });
    }

    const lock = LockService.getScriptLock();
    try {
      lock.waitLock(30000); // Tenta obter o bloqueio por 30 segundos

      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet)
        throw new Error("A planilha 'db_itens_validados' não foi encontrada.");

      const newItemId = generateUniqueId_();
      const currentUser = Session.getActiveUser().getEmail();
      const timestamp = new Date();
      const finalRequestData = {
        ...requestData,
        ...validationResult.autoFilledData,
      };

      const newRow = DB_COLUMN_ORDER.map((header) => {
        switch (header) {
          case "ID_ITEM":
            return newItemId;
          case "STATUS_GERAL":
            return STATUS_GERAL.PENDENTE_SAP;
          case "SOLICITANTE":
            return currentUser;
          case "DATA/HORA 1ª SUBMISSAO":
            return timestamp;
          case "MATERIAL":
            return finalRequestData.material;
          case "DESCRIÇÃO":
            return finalRequestData.descricao;
          case "FORNECEDOR":
            return finalRequestData.fornecedor;
          case "DE (R$)":
            return finalRequestData.precoDe;
          case "POR (R$)":
            return finalRequestData.precoPor;
          case "DATA INÍCIO":
            return parseDate(finalRequestData.dataInicio);
          case "DATA FIM":
            return parseDate(finalRequestData.dataFim);
          case "OBSERVAÇÃO COMERCIAL":
            return finalRequestData.obsComercial;
          // Adicione outros campos conforme necessário
          default:
            return "";
        }
      });

      // Operações de escrita dentro do bloco de bloqueio
      sheet.appendRow(newRow);
      logAction_(
        "CRIAÇÃO",
        newItemId,
        finalRequestData.material,
        { solicitante: currentUser, dados: finalRequestData },
        parseDate(finalRequestData.dataInicio),
        parseDate(finalRequestData.dataFim)
      );

      const cache = CacheService.getScriptCache();
      cache.removeAll([
        "promotions_all_items",
        `promotions_filter_statusFilter:${STATUS_GERAL.PENDENTE_SAP}`,
      ]);

      return JSON.stringify({
        success: true,
        message: `Solicitação '${newItemId}' criada com sucesso.`,
      });
    } catch (e) {
      logSystemEvent(
        LOG_LEVEL.ERROR,
        "createNewRequest",
        `Falha ao criar solicitação: ${(e as Error).message}`
      );
      return JSON.stringify({
        success: false,
        message: `Erro interno ao criar solicitação: ${(e as Error).message}`,
      });
    } finally {
      lock.releaseLock();
    }
  });
}

function validateSku(sku: string): string {
  return measurePerformance("validateSku", () => {
    if (!sku || typeof sku !== "string" || sku.trim() === "") {
      return JSON.stringify({
        success: false,
        message: "SKU inválido ou não fornecido.",
      });
    }
    try {
      const productInfo = getProductInfo_(sku.trim());
      if (productInfo) {
        return JSON.stringify({ success: true, productInfo: productInfo });
      } else {
        return JSON.stringify({
          success: false,
          message: `SKU '${sku.trim()}' não encontrado na base de dados de produtos.`,
        });
      }
    } catch (e) {
      logSystemEvent(
        LOG_LEVEL.ERROR,
        "validateSku",
        `Falha ao validar SKU: ${(e as Error).message}`
      );
      return JSON.stringify({
        success: false,
        message: `Erro interno ao validar SKU: ${(e as Error).message}`,
      });
    }
  });
}

function getPromotionRequestDetails(itemId: string): string {
  return measurePerformance("getPromotionRequestDetails", () => {
    try {
      // 1. Buscar dados da promoção na aba db_itens_validados
      const mainSheet = getSheet_(DB_SHEET_NAME);
      if (!mainSheet)
        throw new Error("A planilha 'db_itens_validados' não foi encontrada.");

      const mainData = mainSheet.getDataRange().getValues();
      const {
        headers: mainHeaders,
        data: mainRows,
        error: mainError,
      } = findHeadersAndData_(mainData);
      if (mainError)
        throw new Error(
          `Erro ao processar a planilha de promoções: ${mainError}`
        );

      const mainIdColIndex = mainHeaders.indexOf("ID_ITEM");
      if (mainIdColIndex === -1)
        throw new Error(
          "A coluna 'ID_ITEM' não foi encontrada na base de dados."
        );

      const rowData = mainRows.find(
        (row) => String(row[mainIdColIndex]) === String(itemId)
      );
      if (!rowData) {
        return JSON.stringify({
          success: false,
          message: `Solicitação com ID '${itemId}' não encontrada.`,
        });
      }

      const itemDetails: { [key: string]: any } = {};
      mainHeaders.forEach((header, index) => {
        itemDetails[header] = rowData[index];
      });

      // Adiciona o imageUrl aos detalhes do item
      const productInfo = getProductInfo_(itemDetails["MATERIAL"]);
      itemDetails.imageUrl = productInfo ? productInfo.imageUrl : null;

      // 2. Buscar todas as entradas de log correspondentes ao itemId na aba log_auditoria
      const auditSheet = getSheet_(AUDIT_LOG_SHEET_NAME);
      let auditHistory = [];
      if (auditSheet) {
        const auditData = auditSheet.getDataRange().getValues();
        const {
          headers: auditHeaders,
          data: auditRows,
          error: auditError,
        } = findHeadersAndData_(auditData, "ID Alvo");

        if (!auditError) {
          const auditIdColIndex = auditHeaders.indexOf("ID Alvo");
          if (auditIdColIndex !== -1) {
            auditHistory = auditRows
              .filter((row) => String(row[auditIdColIndex]) === String(itemId))
              .map((row) => {
                const logEntry: { [key: string]: any } = {};
                auditHeaders.forEach((header, index) => {
                  logEntry[header] = row[index];
                });
                return logEntry;
              })
              .sort(
                (a, b) =>
                  new Date(b.Timestamp).getTime() -
                  new Date(a.Timestamp).getTime()
              );
          }
        } else {
          console.warn(
            `Não foi possível processar o log de auditoria: ${auditError}`
          );
        }
      } else {
        console.warn(
          `A planilha de log de auditoria '${AUDIT_LOG_SHEET_NAME}' não foi encontrada.`
        );
      }

      // 3. O objeto de retorno deve ser JSON, contendo duas chaves: details e auditHistory
      const response = {
        success: true,
        details: itemDetails,
        auditHistory: auditHistory,
      };

      return JSON.stringify(response);
    } catch (e) {
      logSystemEvent(
        LOG_LEVEL.ERROR,
        "getPromotionRequestDetails",
        `Falha ao obter detalhes: ${(e as Error).message}`
      );
      return JSON.stringify({
        success: false,
        message: `Erro interno ao obter detalhes da solicitação: ${
          (e as Error).message
        }`,
      });
    }
  });
}

/**
 * Atualiza o status de uma solicitação de promoção.
 * @param updateData Um objeto contendo o itemId, o novo status e um motivo opcional.
 * @returns Um objeto JSON com o resultado da operação.
 */
function updateRequestStatus(updateData: UpdateRequestData): string {
  return measurePerformance("updateRequestStatus", () => {
    // 1. Requisito de Segurança: Verificar permissão antes de qualquer operação
    if (!checkPermission_("can_approve_requests")) {
      return JSON.stringify({
        success: false,
        message:
          "Acesso negado. Você não tem permissão para aprovar ou recusar solicitações.",
      });
    }

    const lock = LockService.getScriptLock();
    try {
      lock.waitLock(30000); // Tenta obter o bloqueio por 30 segundos

      const sheet = getSheet_(DB_SHEET_NAME);
      if (!sheet)
        throw new Error(`A planilha '${DB_SHEET_NAME}' não foi encontrada.`);

      const allSheetData = sheet.getDataRange().getValues();
      const { headers, data, error, headerRowIndex } =
        findHeadersAndData_(allSheetData);
      if (error) throw new Error(`Erro ao processar planilha: ${error}`);

      const idColIndex = headers.indexOf("ID_ITEM");
      const statusColIndex = headers.indexOf("STATUS_GERAL");
      const reasonColIndex = headers.indexOf("MOTIVO_RECUSA");

      if (idColIndex === -1 || statusColIndex === -1) {
        throw new Error(
          "Não foi possível encontrar as colunas 'ID_ITEM' ou 'STATUS_GERAL'."
        );
      }

      const dataRowIndex = data.findIndex(
        (row) => String(row[idColIndex]) === String(updateData.itemId)
      );

      if (dataRowIndex === -1) {
        return JSON.stringify({
          success: false,
          message: `Solicitação com ID '${updateData.itemId}' não encontrada.`,
        });
      }

      const targetRow = data[dataRowIndex];
      const oldStatus = targetRow[statusColIndex];

      // Calcula a linha absoluta na planilha
      const absoluteSheetRow = headerRowIndex + dataRowIndex + 2;

      // 2. Requisito Transacional: Operações de escrita e auditoria dentro do lock
      sheet
        .getRange(absoluteSheetRow, statusColIndex + 1)
        .setValue(updateData.newStatus);
      if (
        updateData.newStatus === "RECUSADO" &&
        updateData.reason &&
        reasonColIndex !== -1
      ) {
        sheet
          .getRange(absoluteSheetRow, reasonColIndex + 1)
          .setValue(updateData.reason);
      }

      const sku = targetRow[headers.indexOf("MATERIAL")];
      logAction_(
        `MUDANÇA DE STATUS: ${updateData.newStatus}`,
        updateData.itemId,
        sku,
        {
          de: oldStatus,
          para: updateData.newStatus,
          motivo: updateData.reason || "N/A",
        }
      );

      // Invalidar caches para garantir que a UI reflita a mudança
      const cache = CacheService.getScriptCache();
      cache.removeAll([
        "promotions_all_items",
        `promotions_filter_statusFilter:${oldStatus}`,
        `promotions_filter_statusFilter:${updateData.newStatus}`,
      ]);

      return JSON.stringify({
        success: true,
        message: `Status da solicitação '${updateData.itemId}' atualizado para '${updateData.newStatus}'.`,
      });
    } catch (e) {
      logSystemEvent(
        LOG_LEVEL.ERROR,
        "updateRequestStatus",
        `Falha ao atualizar status: ${(e as Error).message}`
      );
      return JSON.stringify({
        success: false,
        message: `Erro interno ao atualizar status: ${(e as Error).message}`,
      });
    } finally {
      lock.releaseLock();
    }
  });
}

// ... e assim por diante para todas as outras funções em processador.js e worker.js

// =================================================================
// PONTO DE ENTRADA E UI CONTROLLER (MIGRADO PARA TYPESCRIPT)
// =================================================================

function doGet(e: GASEvent): HTMLOutput {
  const template = HtmlService.createTemplateFromFile("index");
  (template as any).AVAILABLE_PERMISSIONS = AVAILABLE_PERMISSIONS;
  (template as any).USER_ROLES = USER_ROLES;
  return template
    .evaluate()
    .setTitle("Argus - Portal de Pricing e RGM")
    .setXFrameOptionsMode(HtmlService.XFrameOptionsMode.DEFAULT);
}