Estrutura de Receitas e Customer Lifetime Value

// Calculadora Avançada de Customer Lifetime Value (LTV)
class LTVCalculator {
  constructor(config = {}) {
    // Configurações padrão
    this.receitaMensalMedia = config.receitaMensalMedia || 99;
    this.taxaChurn = config.taxaChurn || 0.05; // 5% ao mês
    this.margemBruta = config.margemBruta || 0.8; // 80%
    this.taxaDesconto = config.taxaDesconto || 0.01; // 1% ao mês
    this.custosSuporteRelativo = config.custosSuporteRelativo || 0.15; // 15% da receita
  }

  // Método 1: LTV Simples
  ltvSimples() {
    const receitaBruta = this.receitaMensalMedia / this.taxaChurn;
    const ltvBruto = receitaBruta * this.margemBruta;
    
    return {
      receitaBruta: receitaBruta,
      ltvBruto: ltvBruto,
      metodo: "Simples (ARPU / Churn Rate)"
    };
  }

  // Método 2: LTV com Valor Presente Líquido
  ltvDescontado(mesesProjecao = 60) {
    let ltvTotal = 0;
    let probabilidadeRetencao = 1;
    
    for (let mes = 1; mes <= mesesProjecao; mes++) {
      // Receita do mês considerando churn
      const receitaMes = this.receitaMensalMedia * probabilidadeRetencao;
      
      // Custos operacionais
      const custosSuporteMes = receitaMes * this.custosSuporteRelativo;
      const receitaLiquidaMes = receitaMes - custosSuporteMes;
      
      // Aplicar margem bruta
      const contribuicaoMes = receitaLiquidaMes * this.margemBruta;
      
      // Descontar para valor presente
      const fatorDesconto = Math.pow(1 + this.taxaDesconto, mes);
      const valorPresenteMes = contribuicaoMes / fatorDesconto;
      
      ltvTotal += valorPresenteMes;
      
      // Atualizar probabilidade de retenção
      probabilidadeRetencao *= (1 - this.taxaChurn);
      
      // Se probabilidade muito baixa, parar cálculo
      if (probabilidadeRetencao < 0.01) break;
    }
    
    return {
      ltvDescontado: ltvTotal,
      metodo: "Valor Presente Líquido",
      mesesConsiderados: mesesProjecao
    };
  }

  // Método 3: LTV por Cohort (mais preciso)
  ltvPorCohort(dadosCohort) {
    // dadosCohort = array de { mes: number, retencao: number, receita: number }
    let ltvCohort = 0;
    
    dadosCohort.forEach(mes => {
      const contribuicao = mes.receita * mes.retencao * this.margemBruta;
      const fatorDesconto = Math.pow(1 + this.taxaDesconto, mes.mes);
      ltvCohort += contribuicao / fatorDesconto;
    });
    
    return {
      ltvCohort: ltvCohort,
      metodo: "Análise de Cohort",
      pontosAnalisados: dadosCohort.length
    };
  }

  // Análise de sensibilidade do LTV
  analiseSensibilidade() {
    const cenarios = [
      { nome: "Pessimista", churn: 0.08, receita: 79, margem: 0.75 },
      { nome: "Realista", churn: 0.05, receita: 99, margem: 0.8 },
      { nome: "Otimista", churn: 0.03, receita: 129, margem: 0.85 }
    ];
    
    console.log("Análise de Sensibilidade do LTV:");
    console.log("================================");
    
    cenarios.forEach(cenario => {
      // Criar calculadora temporária com parâmetros do cenário
      const calc = new LTVCalculator({
        receitaMensalMedia: cenario.receita,
        taxaChurn: cenario.churn,
        margemBruta: cenario.margem
      });
      
      const ltvSimples = calc.ltvSimples();
      const ltvDescontado = calc.ltvDescontado();
      
      console.log(`\n${cenario.nome}:`);
      console.log(`  Churn: ${(cenario.churn * 100).toFixed(1)}%`);
      console.log(`  ARPU: R$ ${cenario.receita}`);
      console.log(`  Margem: ${(cenario.margem * 100).toFixed(0)}%`);
      console.log(`  LTV Simples: R$ ${ltvSimples.ltvBruto.toFixed(2)}`);
      console.log(`  LTV Descontado: R$ ${ltvDescontado.ltvDescontado.toFixed(2)}`);
    });
  }

  // Calcular CAC máximo sustentável
  cacMaximo(ltvMethod = 'simples', racaoLtvCac = 3) {
    let ltv;
    
    if (ltvMethod === 'simples') {
      ltv = this.ltvSimples().ltvBruto;
    } else {
      ltv = this.ltvDescontado().ltvDescontado;
    }
    
    const cacMaximo = ltv / racaoLtvCac;
    
    return {
      ltv: ltv,
      cacMaximo: cacMaximo,
      racaoLtvCac: racaoLtvCac,
      metodo: ltvMethod
    };
  }
}

// Simulação prática
const calculator = new LTVCalculator();

console.log("=== ANÁLISE COMPLETA DE LTV ===\n");

// LTV Simples
const ltvSimples = calculator.ltvSimples();
console.log("1. LTV Simples:");
console.log(`   Receita Bruta: R$ ${ltvSimples.receitaBruta.toFixed(2)}`);
console.log(`   LTV Líquido: R$ ${ltvSimples.ltvBruto.toFixed(2)}\n`);

// LTV Descontado
const ltvDescontado = calculator.ltvDescontado();
console.log("2. LTV Descontado:");
console.log(`   LTV com VPL: R$ ${ltvDescontado.ltvDescontado.toFixed(2)}\n`);

// CAC Máximo
const cacAnalysis = calculator.cacMaximo('descontado', 3);
console.log("3. CAC Máximo Sustentável:");
console.log(`   LTV: R$ ${cacAnalysis.ltv.toFixed(2)}`);
console.log(`   CAC Máximo (1:3): R$ ${cacAnalysis.cacMaximo.toFixed(2)}\n`);

// Análise de sensibilidade
calculator.analiseSensibilidade();

// Dashboard de Métricas SaaS
class MetricasSaaS {
  constructor() {
    this.clientes = new Map(); // clienteId -> dadosCliente
    this.historico = []; // array de snapshots mensais
  }

  // Adicionar novo cliente
  adicionarCliente(clienteId, plano, receita, dataInicio) {
    this.clientes.set(clienteId, {
      id: clienteId,
      plano: plano,
      receitaMensal: receita,
      dataInicio: new Date(dataInicio),
      ativo: true,
      historicoReceitas: [{ data: new Date(dataInicio), receita: receita }]
    });
  }

  // Processar upgrade/downgrade
  alterarPlano(clienteId, novaReceita, data = new Date()) {
    const cliente = this.clientes.get(clienteId);
    if (cliente && cliente.ativo) {
      cliente.receitaMensal = novaReceita;
      cliente.historicoReceitas.push({ data: data, receita: novaReceita });
    }
  }

  // Processar churn
  processarChurn(clienteId, data = new Date()) {
    const cliente = this.clientes.get(clienteId);
    if (cliente) {
      cliente.ativo = false;
      cliente.dataChurn = data;
    }
  }

  // Calcular MRR atual
  calcularMRR() {
    let mrr = 0;
    this.clientes.forEach(cliente => {
      if (cliente.ativo) {
        mrr += cliente.receitaMensal;
      }
    });
    return mrr;
  }

  // Calcular ARR
  calcularARR() {
    return this.calcularMRR() * 12;
  }

  // Calcular ARPU
  calcularARPU() {
    const clientesAtivos = Array.from(this.clientes.values())
      .filter(c => c.ativo).length;
    
    return clientesAtivos > 0 ? this.calcularMRR() / clientesAtivos : 0;
  }

  // Análise de cohort para LTV
  analiseCohort(mesInicio, mesesAnalise = 12) {
    const cohort = Array.from(this.clientes.values())
      .filter(c => {
        const inicioMes = new Date(c.dataInicio);
        inicioMes.setDate(1); // Primeiro dia do mês
        mesInicio.setDate(1);
        return inicioMes.getTime() === mesInicio.getTime();
      });

    const resultados = [];
    const clientesIniciais = cohort.length;

    for (let mes = 0; mes < mesesAnalise; mes++) {
      const dataAnalise = new Date(mesInicio);
      dataAnalise.setMonth(dataAnalise.getMonth() + mes);

      let clientesAtivos = 0;
      let receitaTotal = 0;

      cohort.forEach(cliente => {
        // Cliente ainda ativo na data de análise?
        const ativoNaData = cliente.ativo || 
          (cliente.dataChurn && cliente.dataChurn > dataAnalise);

        if (ativoNaData) {
          clientesAtivos++;
          
          // Encontrar receita na data
          let receitaNaData = cliente.receitaMensal;
          for (let i = cliente.historicoReceitas.length - 1; i >= 0; i--) {
            if (cliente.historicoReceitas[i].data <= dataAnalise) {
              receitaNaData = cliente.historicoReceitas[i].receita;
              break;
            }
          }
          receitaTotal += receitaNaData;
        }
      });

      const retencao = clientesAtivos / clientesIniciais;
      const arpuCohort = clientesAtivos > 0 ? receitaTotal / clientesAtivos : 0;

      resultados.push({
        mes: mes,
        clientesAtivos: clientesAtivos,
        retencao: retencao,
        receitaTotal: receitaTotal,
        arpuCohort: arpuCohort
      });
    }

    return {
      cohortData: resultados,
      clientesIniciais: clientesIniciais,
      mesInicio: mesInicio
    };
  }

  // Calcular NDR (Net Dollar Retention)
  calcularNDR(periodo = 12) { // últimos 12 meses
    const dataLimite = new Date();
    dataLimite.setMonth(dataLimite.getMonth() - periodo);

    const clientesBase = Array.from(this.clientes.values())
      .filter(c => c.dataInicio <= dataLimite);

    let receitaInicial = 0;
    let receitaAtual = 0;

    clientesBase.forEach(cliente => {
      // Receita inicial (há 12 meses)
      receitaInicial += cliente.historicoReceitas[0].receita;

      // Receita atual (se ainda ativo)
      if (cliente.ativo) {
        receitaAtual += cliente.receitaMensal;
      }
      // Se fez churn recentemente, não conta na receita atual
    });

    return receitaInicial > 0 ? (receitaAtual / receitaInicial) * 100 : 0;
  }

  // Relatório completo
  gerarRelatorio() {
    const mrr = this.calcularMRR();
    const arr = this.calcularARR();
    const arpu = this.calcularARPU();
    const ndr = this.calcularNDR();
    const clientesAtivos = Array.from(this.clientes.values())
      .filter(c => c.ativo).length;

    console.log("=== RELATÓRIO DE MÉTRICAS SAAS ===");
    console.log("=================================");
    console.log(`MRR: R$ ${mrr.toLocaleString('pt-BR', {minimumFractionDigits: 2})}`);
    console.log(`ARR: R$ ${arr.toLocaleString('pt-BR', {minimumFractionDigits: 2})}`);
    console.log(`ARPU: R$ ${arpu.toFixed(2)}`);
    console.log(`NDR: ${ndr.toFixed(1)}%`);
    console.log(`Clientes Ativos: ${clientesAtivos}`);
    console.log("");

    // Análise de crescimento (simulada)
    const crescimentoMRR = 15; // 15% ao mês
    console.log("PROJEÇÕES (crescimento 15% ao mês):");
    console.log("===================================");
    for (let mes = 1; mes <= 6; mes++) {
      const mrrProjetado = mrr * Math.pow(1.15, mes);
      console.log(`Mês +${mes}: R$ ${mrrProjetado.toLocaleString('pt-BR', {minimumFractionDigits: 2})}`);
    }
  }
}

// Simulação de empresa SaaS
const empresa = new MetricasSaaS();

// Adicionar clientes
empresa.adicionarCliente('c001', 'Básico', 99, '2024-01-01');
empresa.adicionarCliente('c002', 'Pro', 199, '2024-01-15');
empresa.adicionarCliente('c003', 'Enterprise', 499, '2024-02-01');
empresa.adicionarCliente('c004', 'Básico', 99, '2024-02-15');

// Simular upgrades
empresa.alterarPlano('c001', 199, new Date('2024-03-01')); // Upgrade para Pro
empresa.alterarPlano('c002', 499, new Date('2024-04-01')); // Upgrade para Enterprise

// Simular churn
empresa.processarChurn('c004', new Date('2024-05-01'));

// Gerar relatório
empresa.gerarRelatorio();