ManejoController.gs

/**
 * ManejoController.gs
 * Controlador para operações de manejo (irrigação, fotoperíodo, poda, etc.)
 */

function criarManejo(dados) {
  if (!dados.lote_id) {
    return { sucesso: false, mensagem: 'Lote é obrigatório' };
  }
  
  if (!dados.tipo_manejo) {
    return { sucesso: false, mensagem: 'Tipo de manejo é obrigatório' };
  }
  
  try {
    const lote = obterLote(dados.lote_id);
    if (!lote) {
      return { sucesso: false, mensagem: 'Lote não encontrado' };
    }
    
    const manejoId = gerarIdUnico();
    
    const novoManejo = {
      id: manejoId,
      lote_id: dados.lote_id,
      data_manejo: dados.data_manejo || formatarDataBR(new Date()),
      tipo_manejo: dados.tipo_manejo,
      observacoes: dados.observacoes || '',
      responsavel_id: dados.responsavel_id || '',
      resultado: dados.resultado || 'pendente'
    };
    
    inserirObjeto(SHEET_NAMES.MANEJOS, novoManejo);
    
    // Se é um manejo importante, registra em auditoria
    if (['FOTOPERIODO', 'COLHEITA'].includes(dados.tipo_manejo)) {
      registrarAuditoria(dados.responsavel_id, 'MANEJO_CRITICO', `Manejo ${dados.tipo_manejo} para lote ${dados.lote_id}`);
    }
    
    return { sucesso: true, mensagem: 'Manejo registrado com sucesso', manejoId: manejoId };
  } catch (erro) {
    tratarErro(erro, 'criarManejo');
    return { sucesso: false, mensagem: 'Erro ao criar manejo' };
  }
}

function listarManejos(filtros = {}) {
  const manejos = obterTodosOsDadosComoObjetos(SHEET_NAMES.MANEJOS);
  
  let resultado = manejos;
  
  if (filtros.lote_id) {
    resultado = resultado.filter(m => m.lote_id === filtros.lote_id);
  }
  
  if (filtros.tipo_manejo) {
    resultado = resultado.filter(m => m.tipo_manejo === filtros.tipo_manejo);
  }
  
  if (filtros.responsavel_id) {
    resultado = resultado.filter(m => m.responsavel_id === filtros.responsavel_id);
  }
  
  return resultado;
}

function obterManejo(manejoId) {
  return buscarUmPorColuna(SHEET_NAMES.MANEJOS, 'id', manejoId);
}

function atualizarManejo(manejoId, dados) {
  try {
    const manejo = obterManejo(manejoId);
    if (!manejo) {
      return { sucesso: false, mensagem: 'Manejo não encontrado' };
    }
    
    atualizarPorCriterios(SHEET_NAMES.MANEJOS, { id: manejoId }, dados);
    
    return { sucesso: true, mensagem: 'Manejo atualizado com sucesso' };
  } catch (erro) {
    tratarErro(erro, 'atualizarManejo');
    return { sucesso: false, mensagem: 'Erro ao atualizar manejo' };
  }
}

/**
 * Registra um manejo de irrigação
 * @param {string} loteId - ID do lote
 * @param {Object} dados - { volume_litros, responsavel_id, observacoes }
 */
function registrarIrrigacao(loteId, dados) {
  return criarManejo({
    lote_id: loteId,
    tipo_manejo: TIPOS_MANEJO.IRRIGACAO,
    observacoes: `Volume: ${dados.volume_litros}L - ${dados.observacoes || ''}`,
    responsavel_id: dados.responsavel_id,
    resultado: 'concluído'
  });
}

/**
 * Registra um manejo de fotoperíodo (para crisântemos)
 * @param {string} loteId - ID do lote
 * @param {Object} dados - { tipo_luz, horas_escuridao, responsavel_id }
 */
function registrarFotoperiodo(loteId, dados) {
  const observacoes = `Tipo: ${dados.tipo_luz}, Horas de escuridão: ${dados.horas_escuridao}h`;
  
  return criarManejo({
    lote_id: loteId,
    tipo_manejo: TIPOS_MANEJO.FOTOPERIODO,
    observacoes: observacoes,
    responsavel_id: dados.responsavel_id,
    resultado: 'concluído'
  });
}

/**
 * Registra um manejo de poda
 * @param {string} loteId - ID do lote
 * @param {Object} dados - { tipo_poda, responsavel_id, observacoes }
 */
function registrarPoda(loteId, dados) {
  return criarManejo({
    lote_id: loteId,
    tipo_manejo: TIPOS_MANEJO.PODA,
    observacoes: `Tipo: ${dados.tipo_poda} - ${dados.observacoes || ''}`,
    responsavel_id: dados.responsavel_id,
    resultado: 'concluído'
  });
}

/**
 * Registra um manejo de adubação
 * @param {string} loteId - ID do lote
 * @param {Object} dados - { tipo_adubo, dosagem, responsavel_id }
 */
function registrarAdubacao(loteId, dados) {
  return criarManejo({
    lote_id: loteId,
    tipo_manejo: TIPOS_MANEJO.ADUBACAO,
    observacoes: `Adubo: ${dados.tipo_adubo}, Dosagem: ${dados.dosagem}`,
    responsavel_id: dados.responsavel_id,
    resultado: 'concluído'
  });
}

/**
 * Registra um manejo de controle de pragas
 * @param {string} loteId - ID do lote
 * @param {Object} dados - { praga_identificada, produto_usado, responsavel_id }
 */
function registrarControlePragas(loteId, dados) {
  return criarManejo({
    lote_id: loteId,
    tipo_manejo: TIPOS_MANEJO.CONTROLE_PRAGAS,
    observacoes: `Praga: ${dados.praga_identificada}, Produto: ${dados.produto_usado}`,
    responsavel_id: dados.responsavel_id,
    resultado: 'concluído'
  });
}

/**
 * Obtém histórico de manejos de um lote
 * @param {string} loteId - ID do lote
 * @returns {Array} Array de manejos ordenados por data
 */
function obterHistoricoManejos(loteId) {
  const manejos = listarManejos({ lote_id: loteId });
  return ordenarPorPropriedade(manejos, 'data_manejo', 'desc');
}

/**
 * Calcula a próxima data de irrigação baseada no histórico
 * @param {string} loteId - ID do lote
 * @returns {Date|null} Próxima data estimada ou null
 */
function calcularProximaIrrigacao(loteId) {
  const manejos = listarManejos({ lote_id: loteId, tipo_manejo: TIPOS_MANEJO.IRRIGACAO });
  
  if (manejos.length < 2) return null;
  
  const ultimoManejo = manejos[manejos.length - 1];
  const penultimoManejo = manejos[manejos.length - 2];
  
  const diasEntre = calcularDiasEntreDatas(
    parsearDataBR(penultimoManejo.data_manejo),
    parsearDataBR(ultimoManejo.data_manejo)
  );
  
  const proximaData = adicionarDias(parsearDataBR(ultimoManejo.data_manejo), diasEntre);
  
  return proximaData;
}