# app/controllers/consolidacao_entregas_controller.rb
class ConsolidacaoEntregasController < ApplicationController
  include Auditavel

  before_action :set_consolidacao
  before_action :bloquear_se_finalizada, except: %i[validar revisar]

  # Rótulo/sentinela do grupo de entregas sem veículo no filtro "fechar por carro".
  SEM_VEICULO = '(sem veículo)'.freeze

  # GET /consolidacoes/:consolidacao_id/consolidacao_entregas/validar?motorista=X
  # WIZARD PASSO 2 — tela de validação com toggles
  def validar
    authorize @consolidacao, :show?
    @motorista = params[:motorista]
    @veiculo   = params[:vehicle].presence   # filtro "fechar por carro" (opcional)

    # Entregas atendidas do período no banco existente (read-only): sucesso +
    # insucesso, pois o motorista foi ao local e a entrega precisa constar.
    # Período pela DATA REAL (checkout), não pela planejada.
    @entregas = Entrega.atendidas
                       .da_conta_gade
                       .no_periodo_checkout(@consolidacao.data_inicio, @consolidacao.data_fim)
                       .do_motorista(@motorista)
    @entregas = @entregas.da_veiculo(@consolidacao.vehicle_ids)  if @consolidacao.vehicle_ids.present?
    @entregas = @entregas.da_operacoes(@consolidacao.operacoes)  if @consolidacao.operacoes.present?
    @entregas = filtrar_por_veiculo(@entregas, @veiculo)         if @veiculo
    @entregas = @entregas.order(:checkout)

    # Classificações já feitas — agrupadas por tracking_id (uma entrega pode ter
    # vários pilares). { tracking_id => [ConsolidacaoEntrega, ...] }
    @classificacoes = @consolidacao.consolidacao_entregas
                                   .where(motorista_nome: @motorista)
                                   .group_by(&:tracking_id)

    # Status "fechado" por veículo (filtro + acompanhamento) e totais com escopo:
    # quando um carro está selecionado, a barra reflete só aquele carro.
    @veiculos_status = veiculos_status(@motorista)
    if @veiculo
      atual = @veiculos_status.find { |v| v[:vehicle] == @veiculo }
      @total_entregas = atual ? atual[:eligible]      : 0
      @classificadas  = atual ? atual[:classificadas] : 0
    else
      @total_entregas = @consolidacao.entregas_elegiveis_count(@motorista)
      @classificadas  = @consolidacao.classificadas_count(@motorista)
    end

    # Nomes dos motoristas ATIVOS — alimenta o seletor do apontamento 100% manual.
    @motoristas_consolidacao = @consolidacao.consolidacao_motoristas.ativos.pluck(:motorista_nome)

    # Filtro "apenas não classificadas"
    if params[:apenas_pendentes] == '1'
      @entregas = @entregas.reject { |e| @classificacoes.key?(e.tracking_id) }
    end

    @precos = {
      entrega_normal: Configuracao.preco_entrega,
      retirada:       Configuracao.preco_retirada,
      bonus:          Configuracao.preco_bonus,
      desconto:       Configuracao.preco_desconto,
      extraordinaria: Configuracao.preco_extraordinaria
    }
  end

  # POST /consolidacoes/:consolidacao_id/consolidacao_entregas/classificar
  # Classifica UMA entrega (chamado pelo toggle via Turbo/fetch)
  def classificar
    authorize @consolidacao, :update?

    return render_nao_elegivel unless entrega_elegivel?(params[:motorista], params[:tracking_id])

    # Toggle do pilar: se já existe, remove; senão, adiciona (permite combinar
    # vários pilares na mesma entrega).
    ce = @consolidacao.consolidacao_entregas
                      .find_by(tracking_id: params[:tracking_id], tipo: params[:tipo])
    if ce
      ce.destroy
      ativo = false
    else
      @consolidacao.consolidacao_entregas.create!(
        tracking_id:    params[:tracking_id],
        motorista_nome: params[:motorista],
        tipo:           params[:tipo],
        valor_aplicado: valor_classificacao(params[:tipo]),
        created_by:     current_user.id
      )
      ativo = true
    end

    recalcular_motorista(params[:motorista])

    respond_to do |format|
      format.json do
        render json: resumo_json(params[:motorista], vehicle: params[:vehicle].presence).merge(
          ativo: ativo, tracking_id: params[:tracking_id], tipo: params[:tipo]
        )
      end
      format.html { redirect_back fallback_location: wizard_consolidacao_path(@consolidacao) }
    end
  end

  # POST /consolidacoes/:consolidacao_id/consolidacao_entregas/classificar_em_massa
  # Ações em massa: marcar todos / marcar selecionados
  def classificar_em_massa
    authorize @consolidacao, :update?

    tipo         = params[:tipo]
    motorista    = params[:motorista]
    tracking_ids = Array(params[:tracking_ids]).reject(&:blank?)

    return render_nao_elegivel unless motorista_na_consolidacao?(motorista)

    # Recorte por veículo (fechar um carro de cada vez). Sem veículo = todos.
    elegiveis = tracking_ids_elegiveis(motorista, params[:vehicle].presence)
    # Sem tracking_ids = todas as elegíveis do período/veículo (botão "todos").
    # Com tracking_ids → mantém só as que de fato são elegíveis para o motorista.
    tracking_ids = tracking_ids.empty? ? elegiveis : (tracking_ids & elegiveis)

    remover = params[:acao].to_s == 'remover'

    ActiveRecord::Base.transaction do
      if remover
        # Desmarca o pilar das entregas selecionadas (mantém os demais pilares).
        @consolidacao.consolidacao_entregas
                     .where(motorista_nome: motorista, tipo: tipo, tracking_id: tracking_ids)
                     .destroy_all
      else
        # ADICIONA o pilar às entregas (não remove os demais já marcados).
        valor = valor_classificacao(tipo)
        tracking_ids.each do |tid|
          ce = @consolidacao.consolidacao_entregas.find_or_initialize_by(tracking_id: tid, tipo: tipo)
          ce.assign_attributes(motorista_nome: motorista,
                               valor_aplicado: valor, created_by: current_user.id)
          ce.save!
        end
      end
    end

    recalcular_motorista(motorista)
    auditar!(:editar, @consolidacao,
             dados_novos: { acao_massa: tipo, modo: (remover ? 'remover' : 'adicionar'),
                            qtd: tracking_ids.size, motorista: motorista })

    respond_to do |format|
      format.json { render json: resumo_json(motorista, vehicle: params[:vehicle].presence) }
      format.html do
        verbo = remover ? 'desmarcadas de' : 'marcadas como'
        redirect_to validar_consolidacao_consolidacao_entregas_path(@consolidacao, motorista: motorista, vehicle: params[:vehicle].presence),
                    notice: "#{tracking_ids.size} entregas #{verbo} #{tipo.humanize}."
      end
    end
  end

  # GET /consolidacoes/:consolidacao_id/consolidacao_entregas/revisar?motorista=X
  # WIZARD PASSO 3 — revisão do motorista
  def revisar
    authorize @consolidacao, :show?
    @motorista = params[:motorista]

    todas = @consolidacao.consolidacao_entregas.where(motorista_nome: @motorista)

    # Agregados calculados sobre o conjunto COMPLETO (não só a página exibida).
    # sum(:quantidade) (default 1) conta os termos lançados em lote como N entregas.
    @resumo = todas.group(:tipo).sum(:quantidade)
    @total  = todas.sum do |c|
      c.tipo == 'desconto' ? -c.valor_aplicado : c.valor_aplicado
    end
    @total_pilares       = todas.count
    @total_classificadas = todas.distinct.count(:tracking_id)

    # Paginação só da tabela exibida — 20 padrão, com seletor 20/50/100
    @por_pagina = [20, 50, 100].include?(params[:por_pagina].to_i) ? params[:por_pagina].to_i : 20
    begin
      @pagy, @classificacoes = pagy(todas.order(:created_at), limit: @por_pagina)
    rescue Pagy::OverflowError
      @pagy, @classificacoes = pagy(todas.order(:created_at), limit: @por_pagina, page: 1)
    end

    # Próximo motorista pendente (para botão "Próximo Motorista") — só ativos
    nomes_completos = @consolidacao.consolidacao_motoristas.ativos.map(&:motorista_nome)
    @proximo = nomes_completos.find do |nome|
      next false if nome == @motorista
      total = @consolidacao.entregas_elegiveis_count(nome)
      @consolidacao.classificadas_count(nome) < total
    end
  end

  # GET /consolidacoes/:consolidacao_id/consolidacao_entregas/buscar_nf?nf=123
  # APONTAMENTO MANUAL — busca a NF na SimpleRoute (sem filtro de período).
  def buscar_nf
    authorize @consolidacao, :update?

    nf = params[:nf].to_s.strip
    return render(json: { ok: false, erro: 'Informe o número da nota.' }, status: :unprocessable_entity) if nf.blank?

    entregas = Entrega.da_conta_gade.por_nf(nf).order(:checkout)

    if entregas.empty?
      render json: { ok: false, erro: "Nota #{nf} não encontrada na base de rastreio." }
    else
      render json: { ok: true, nf: nf, entregas: entregas.map(&:resumo_apontamento) }
    end
  end

  # POST /consolidacoes/:consolidacao_id/consolidacao_entregas/apontar
  # Cria um apontamento manual a partir de um tracking_id encontrado pela NF.
  # Aceita um ou vários pilares (tipos[]) na mesma entrega.
  def apontar
    authorize @consolidacao, :update?

    entrega = Entrega.da_conta_gade.find_by(tracking_id: params[:tracking_id])
    return render_apontamento_erro('Entrega não encontrada na base de rastreio.') unless entrega

    motorista = @consolidacao.adicionar_apontamento!(entrega, tipos_param, current_user)
    auditar!(:editar, @consolidacao,
             dados_novos: { apontamento_manual: entrega.numero_nf, tipos: tipos_param, motorista: motorista })

    respond_to do |format|
      format.json { render json: resumo_json(motorista).merge(motorista: motorista) }
      format.html do
        redirect_to validar_consolidacao_consolidacao_entregas_path(@consolidacao, motorista: motorista),
                    notice: "Apontamento da nota #{entrega.numero_nf} adicionado para #{motorista}."
      end
    end
  rescue ArgumentError => e
    render_apontamento_erro(e.message)
  end

  # POST /consolidacoes/:consolidacao_id/consolidacao_entregas/apontar_manual
  # Apontamento 100% MANUAL — não consulta a base de rastreio. O admin informa o
  # motorista (pode ser outro que não o da tela), a NF (texto livre), uma
  # observação/local e os pilares. Usado quando o motorista foi ao local mas a
  # NF ficou registrada com outro motorista no rastreio.
  def apontar_manual
    authorize @consolidacao, :update?

    motorista = @consolidacao.adicionar_apontamento_manual!(
      motorista:   params[:motorista].to_s.strip,
      tipos:       tipos_param,
      nf:          params[:nf],
      obs:         params[:obs],
      valor_extra: valor_extraordinaria_param,
      user:        current_user
    )
    auditar!(:editar, @consolidacao,
             dados_novos: { apontamento_100_manual: params[:nf], motorista: motorista, tipos: tipos_param })

    respond_to do |format|
      format.json { render json: resumo_json(motorista).merge(motorista: motorista) }
      format.html do
        redirect_to validar_consolidacao_consolidacao_entregas_path(@consolidacao, motorista: motorista),
                    notice: "Apontamento manual adicionado para #{motorista}."
      end
    end
  rescue ArgumentError => e
    render_apontamento_erro(e.message)
  end

  # POST /consolidacoes/:consolidacao_id/consolidacao_entregas/apontar_termo
  # ENTREGA DE TERMO — lança um lote de N termos para o motorista. Não há NF nem
  # código de rastreio: só a quantidade, a um preço fixo configurável.
  def apontar_termo
    authorize @consolidacao, :update?

    motorista = @consolidacao.adicionar_termos!(
      motorista:  params[:motorista].to_s.strip,
      quantidade: params[:quantidade],
      user:       current_user
    )
    auditar!(:editar, @consolidacao,
             dados_novos: { entrega_termo: params[:quantidade].to_i, motorista: motorista })

    respond_to do |format|
      format.json { render json: resumo_json(motorista).merge(motorista: motorista) }
      format.html do
        redirect_to validar_consolidacao_consolidacao_entregas_path(@consolidacao, motorista: motorista),
                    notice: "#{params[:quantidade].to_i} entrega(s) de termo adicionada(s) para #{motorista}."
      end
    end
  rescue ArgumentError => e
    render_apontamento_erro(e.message)
  end

  # DELETE /consolidacoes/:consolidacao_id/consolidacao_entregas/remover_apontamento
  # Remove um apontamento manual — por ?id= (um pilar) ou por ?tracking_id=&motorista=
  # (todos os pilares daquela nota). Não passa pelo guard de elegibilidade, pois o
  # tracking está fora do período (por isso não reusa o toggle classificar).
  def remover_apontamento
    authorize @consolidacao, :update?

    scope     = @consolidacao.consolidacao_entregas.apontamentos
    registros = if params[:id].present?
                  Array(scope.find_by(id: params[:id]))
                else
                  scope.where(tracking_id: params[:tracking_id], motorista_nome: params[:motorista]).to_a
                end
    return render_apontamento_erro('Apontamento não encontrado.') if registros.empty?

    motorista = registros.first.motorista_nome
    tracking  = registros.first.tracking_id
    registros.each(&:destroy)
    @consolidacao.recalcular_motorista!(motorista)
    auditar!(:editar, @consolidacao,
             dados_novos: { remover_apontamento_manual: tracking, motorista: motorista })

    respond_to do |format|
      format.json { render json: resumo_json(motorista).merge(motorista: motorista) }
      format.html { redirect_back fallback_location: consolidacao_path(@consolidacao), notice: 'Apontamento removido.' }
    end
  end

  private

  def set_consolidacao
    @consolidacao = Consolidacao.find(params[:consolidacao_id])
  end

  def bloquear_se_finalizada
    return unless @consolidacao.finalizada? && current_user.operador?
    redirect_to @consolidacao, alert: 'Consolidação finalizada — apenas admin/gerente podem editar.'
  end

  # Motorista realmente faz parte desta consolidação? (ignora arquivados)
  def motorista_na_consolidacao?(nome)
    nome.present? && @consolidacao.consolidacao_motoristas.ativos.exists?(motorista_nome: nome)
  end

  # tracking_ids atendidos/elegíveis para o motorista no período (respeita veículos).
  # Atendidas = sucesso + insucesso com checkout (o motorista foi ao local).
  # `vehicle` (opcional) recorta para UM carro — é o que faz "Marcar todos" fechar
  # só o veículo selecionado.
  def tracking_ids_elegiveis(motorista, vehicle = nil)
    return [] unless motorista.present?

    rel = Entrega.atendidas.da_conta_gade
                 .no_periodo_checkout(@consolidacao.data_inicio, @consolidacao.data_fim)
                 .do_motorista(motorista)
    rel = rel.da_veiculo(@consolidacao.vehicle_ids)  if @consolidacao.vehicle_ids.present?
    rel = rel.da_operacoes(@consolidacao.operacoes)  if @consolidacao.operacoes.present?
    rel = filtrar_por_veiculo(rel, vehicle)          if vehicle.present?
    rel.pluck(:tracking_id)
  end

  # Recorte por um único veículo (trata o grupo "sem veículo").
  def filtrar_por_veiculo(rel, veiculo)
    veiculo == SEM_VEICULO ? rel.where(vehicle: [nil, '']) : rel.da_veiculo(veiculo)
  end

  # Status "fechado" por veículo do motorista: lista de
  # { vehicle:, eligible:, classificadas:, fechado: }. Fonte única do filtro de
  # carros e do acompanhamento (chips). 2 queries: elegíveis (com a coluna do
  # veículo) e as já classificadas (não-manuais).
  def veiculos_status(motorista)
    return [] unless motorista.present?

    rel = Entrega.atendidas.da_conta_gade
                 .no_periodo_checkout(@consolidacao.data_inicio, @consolidacao.data_fim)
                 .do_motorista(motorista)
    rel = rel.da_veiculo(@consolidacao.vehicle_ids)  if @consolidacao.vehicle_ids.present?
    rel = rel.da_operacoes(@consolidacao.operacoes)  if @consolidacao.operacoes.present?

    por_veiculo = rel.pluck(:tracking_id, :vehicle).group_by { |(_id, v)| v.presence || SEM_VEICULO }
    classificadas = @consolidacao.consolidacao_entregas
                                 .where(motorista_nome: motorista, manual: false)
                                 .distinct.pluck(:tracking_id).to_set

    por_veiculo.map do |veiculo, linhas|
      ids   = linhas.map(&:first)
      feito = ids.count { |id| classificadas.include?(id) }
      { vehicle: veiculo, eligible: ids.size, classificadas: feito,
        fechado: ids.size.positive? && feito >= ids.size }
    end.sort_by { |v| v[:vehicle] }
  end

  # Valida que a entrega pertence ao motorista informado e ao período/veículo da
  # consolidação — impede classificar tracking_ids arbitrários via requisição.
  def entrega_elegivel?(motorista, tracking_id)
    motorista_na_consolidacao?(motorista) &&
      tracking_id.present? &&
      tracking_ids_elegiveis(motorista).include?(tracking_id)
  end

  # Pilares (tipos) selecionados no modal — aceita tipos[] (vários) ou tipo (um).
  def tipos_param
    tipos = Array(params[:tipos]).presence || Array(params[:tipo])
    tipos.reject(&:blank?)
  end

  def render_apontamento_erro(msg)
    respond_to do |format|
      format.json { render json: { ok: false, erro: msg }, status: :unprocessable_entity }
      format.html { redirect_to wizard_consolidacao_path(@consolidacao), alert: msg }
    end
  end

  def render_nao_elegivel
    respond_to do |format|
      format.json { render json: { ok: false, erro: 'Entrega não elegível para este motorista.' }, status: :unprocessable_entity }
      format.html do
        redirect_to validar_consolidacao_consolidacao_entregas_path(@consolidacao, motorista: params[:motorista]),
                    alert: 'Entrega não elegível para este motorista.'
      end
    end
  end

  def valor_para_tipo(tipo)
    ConsolidacaoEntrega.valor_para(tipo)
  end

  # Valor a aplicar na classificação. Para o pilar "extraordinária" o admin pode
  # informar um valor customizado (params[:valor]) por ser uma exceção; se vier
  # ausente/inválido, cai no preço padrão de Configurações. Demais pilares usam
  # sempre o preço configurado.
  def valor_classificacao(tipo)
    return valor_para_tipo(tipo) unless tipo.to_s == 'extraordinaria'

    valor = params[:valor].to_s.strip.tr(',', '.')
    valor = BigDecimal(valor) rescue nil
    valor.present? && valor >= 0 ? valor : Configuracao.preco_extraordinaria
  end

  # Valor customizado da Extraordinária vindo do formulário (params[:valor]),
  # aceitando vírgula decimal. Retorna nil se ausente/inválido — aí o model usa
  # o preço padrão de Configurações.
  def valor_extraordinaria_param
    bruto = params[:valor].to_s.strip.tr(',', '.')
    return nil if bruto.blank?

    valor = BigDecimal(bruto) rescue nil
    valor if valor && valor >= 0
  end

  def recalcular_motorista(nome)
    @consolidacao.recalcular_motorista!(nome)
  end

  # `vehicle` (opcional): quando presente, `classificadas_escopo` reflete só aquele
  # carro (para a barra de progresso por veículo). `veiculos_status` acompanha o
  # payload para o front atualizar os chips sem recarregar.
  def resumo_json(motorista, vehicle: nil)
    classificacoes = @consolidacao.consolidacao_entregas.where(motorista_nome: motorista)
    status         = veiculos_status(motorista)
    classificadas  = classificacoes.distinct.count(:tracking_id)
    escopo = if vehicle.present?
               (status.find { |v| v[:vehicle] == vehicle } || {})[:classificadas] || 0
             else
               classificadas
             end
    {
      ok: true,
      classificadas:        classificadas,
      classificadas_escopo: escopo,
      por_tipo:             classificacoes.group(:tipo).count,
      valor_total:          classificacoes.sum { |e| e.tipo == 'desconto' ? -e.valor_aplicado : e.valor_aplicado }.to_f,
      veiculos_status:      status
    }
  end
end