Reem-Notas/app/controllers/dashboard_controller.rb

# app/controllers/dashboard_controller.rb
class DashboardController < ApplicationController
  MAX_DIAS_GRAFICO = 92  # limita a granularidade diária do gráfico (≈ 1 trimestre)

  def index
    skip_authorization

    # Motorista tem painel próprio — não enxerga o dashboard administrativo
    return redirect_to(motorista_dashboard_path) if current_user.motorista?

    @periodo_inicio, @periodo_fim = periodo_selecionado
    carregar_dados_dashboard
  end

  private

  # Faixa de datas vinda do filtro de calendário (params inicio/fim).
  # Default: do início do mês corrente até hoje. Datas inválidas caem no default
  # e a ordem é normalizada caso venham invertidas.
  def periodo_selecionado
    inicio = parse_data(params[:inicio]) || Date.current.beginning_of_month
    fim    = parse_data(params[:fim])    || Date.current
    inicio, fim = fim, inicio if fim < inicio
    [inicio, fim]
  end

  # Parse tolerante: data inválida/ausente vira nil (para o default assumir).
  def parse_data(str)
    return nil if str.blank?
    Date.parse(str)
  rescue ArgumentError, TypeError
    nil
  end

  def carregar_dados_dashboard
    # Filtro de operação (multi-seleção) — aplicado a todo o dashboard.
    @operacoes       = Operacao.todas
    @operacao_filtro = Operacao.sanitizar(params[:operacoes])

    # Entregas do período (tabela read-only) — restritas à conta Gade
    entregas = Entrega.da_conta_gade.no_periodo(@periodo_inicio, @periodo_fim)
    entregas = entregas.da_operacoes(@operacao_filtro) if @operacao_filtro.present?

    # Totais gerais
    @total_entregas     = entregas.count
    @entregas_pagas     = entregas.pagas.count
    @entregas_pendentes = @total_entregas - @entregas_pagas

    # Configurações de preço
    config = Configuracao.mapa_de_precos

    # Valor estimado total
    @valor_estimado = (@entregas_pagas * config[:entrega]).round(2)

    # Por motorista (top 10)
    @motoristas = entregas.pagas
                          .group(:driver)
                          .count
                          .sort_by { |_, v| -v }
                          .first(10)
                          .map do |driver, qtd|
      {
        nome: driver,
        entregas: qtd,
        valor: (qtd * config[:entrega]).round(2)
      }
    end

    # Por local de entrega (contact_name)
    @por_operacao = entregas.pagas
                            .group(:contact_name)
                            .count
                            .sort_by { |_, v| -v }
                            .first(6)
                            .to_h

    # Evolução diária no período (para Chart.js)
    @grafico_diario = build_grafico_diario(entregas, config[:entrega])

    # Consolidações cujo período (data_inicio..data_fim) cruza o período do dashboard
    # — independe de quando foram criadas (created_at).
    @consolidacoes_mes = Consolidacao.ativas
                                     .where('data_inicio <= ? AND data_fim >= ?', @periodo_fim, @periodo_inicio)
    @consolidacoes_mes = @consolidacoes_mes.com_operacoes(@operacao_filtro) if @operacao_filtro.present?
    @consolidacoes_abertas = @consolidacoes_mes.where(status: :rascunho).count
    @consolidacoes_fechadas = @consolidacoes_mes.where(status: :finalizada).count

    # Pagamentos: pago vs pendente entre as consolidações FINALIZADAS do período
    # (medido por motorista — fonte: consolidacao_motoristas).
    carregar_dados_pagamentos

    # Visão financeira por operação (KPIs + gráficos)
    carregar_dados_financeiro

    # Histórico estimado mais recente
    @historico_recente = HistoricoEstimado.order(created_at: :desc).limit(5)
  end

  def carregar_dados_pagamentos
    intervalo = @periodo_inicio.beginning_of_day..@periodo_fim.end_of_day

    # PAGOS: filtrados pela DATA DO PAGAMENTO (pago_em) dentro do período do topo
    # — "quanto foi pago neste período".
    pagos = ConsolidacaoMotorista
              .joins(:consolidacao)
              .where(consolidacoes: { status: :finalizada, deleted_at: nil })
              .where(pago_em: intervalo)
    if @operacao_filtro.present?
      pagos = pagos.where(consolidacao_id: Consolidacao.com_operacoes(@operacao_filtro).select(:id))
    end
    @pag_pago_qtd   = pagos.count
    @pag_pago_valor = pagos.sum(:valor_total)

    # PENDENTES: consolidações finalizadas cujo PERÍODO cruza o filtro, ainda sem
    # pagamento (pendente não tem data de pagamento para filtrar).
    finalizadas_ids = @consolidacoes_mes.where(status: :finalizada).select(:id)
    pendentes = ConsolidacaoMotorista.where(consolidacao_id: finalizadas_ids).pendentes
    @pag_pend_qtd   = pendentes.count
    @pag_pend_valor = pendentes.sum(:valor_total)

    @pagamentos_feitos    = pagos.includes(:consolidacao, :pagador).order(pago_em: :desc)
    @pagamentos_pendentes = pendentes.includes(:consolidacao).order(consolidacao_id: :desc)
  end

  # Visão financeira (custo) das consolidações finalizadas do período, já com o
  # filtro de operação aplicado.
  def carregar_dados_financeiro
    intervalo = @periodo_inicio.beginning_of_day..@periodo_fim.end_of_day

    base = Consolidacao.ativas.where(status: :finalizada)
    base = base.com_operacoes(@operacao_filtro) if @operacao_filtro.present?

    # Consolidações relevantes ao período: as que CRUZAM o período OU que tiveram
    # algum pagamento feito dentro do período. Sem o 2º caso, pagar uma
    # consolidação de outro mês não mexia nos gráficos (só na tabela de pagamentos).
    ids_periodo = base.where('data_inicio <= ? AND data_fim >= ?', @periodo_fim, @periodo_inicio).ids
    ids_pagos   = ConsolidacaoMotorista.where(pago_em: intervalo)
                                       .where(consolidacao_id: base.select(:id))
                                       .distinct.pluck(:consolidacao_id)

    consols = Consolidacao.where(id: (ids_periodo + ids_pagos).uniq).to_a
    ids = consols.map(&:id)
    cms = ConsolidacaoMotorista.where(consolidacao_id: ids)
    ces = ConsolidacaoEntrega.where(consolidacao_id: ids)

    # KPIs
    @fin_custo_total  = cms.sum(:valor_total)
    @fin_qtd_entregas = ces.distinct.count(:tracking_id)
    @fin_ticket_medio = @fin_qtd_entregas.zero? ? 0 : (@fin_custo_total / @fin_qtd_entregas)
    @fin_pago         = cms.pagos.sum(:valor_total)
    @fin_pendente     = cms.pendentes.sum(:valor_total)

    # Custo por operação — rateia o valor da consolidação igualmente entre suas
    # operações (mantém o total consistente; exato no caso de 1 operação).
    por_op = Hash.new(0)
    consols.each do |c|
      ops = c.operacoes.presence || ['(sem operação)']
      fatia = c.valor_total / ops.size
      ops.each { |o| por_op[o == '(sem operação)' ? o : Operacao.label(o)] += fatia }
    end
    @fin_por_operacao = por_op.sort_by { |_, v| -v }

    # Composição por tipo (normal/retirada/bônus/desconto)
    soma_tipo = ces.group(:tipo).sum(:valor_aplicado)
    @fin_por_tipo = ConsolidacaoEntrega::TIPO_CORES.filter_map do |tipo, cfg|
      valor = soma_tipo[tipo].to_f
      next if valor.zero?
      { label: cfg[:label], valor: valor }
    end

    # Custo por motorista (top 10)
    @fin_por_motorista = cms.group(:motorista_nome).sum(:valor_total)
                            .sort_by { |_, v| -v }.first(10)
  end

  def build_grafico_diario(entregas, preco_entrega)
    dias = (@periodo_inicio..@periodo_fim).to_a

    if dias.size <= MAX_DIAS_GRAFICO
      # Granularidade diária (períodos curtos)
      contagem = entregas.pagas.group("DATE(planned_date)").count.transform_keys(&:to_s)
      labels  = dias.map { |d| d.strftime('%d/%m') }
      valores = dias.map { |d| ((contagem[d.to_s] || 0) * preco_entrega).round(2) }
      qtds    = dias.map { |d| contagem[d.to_s] || 0 }
    else
      # Período longo: agrega por mês para o gráfico não ficar vazio nem poluído.
      contagem = entregas.pagas.group("TO_CHAR(planned_date, 'YYYY-MM')").count
      meses   = meses_no_periodo
      labels  = meses.map { |m| Date.strptime(m, '%Y-%m').strftime('%m/%Y') }
      valores = meses.map { |m| ((contagem[m] || 0) * preco_entrega).round(2) }
      qtds    = meses.map { |m| contagem[m] || 0 }
    end

    { labels: labels, valores: valores, qtds: qtds }
  end

  # Meses ("YYYY-MM") do início ao fim do período selecionado, inclusive.
  def meses_no_periodo
    meses  = []
    cursor = @periodo_inicio.beginning_of_month
    while cursor <= @periodo_fim
      meses << cursor.strftime('%Y-%m')
      cursor = cursor.next_month
    end
    meses
  end
end