aperonight/app/controllers/tickets_controller.rb

# Manage tickets creation
#
# This controller permit users to create a new ticket for an event,
# complete their details and proceed to payment
class TicketsController < ApplicationController
  before_action :authenticate_user!, only: [ :new ]
  before_action :set_event, only: [ :new ]

  # Handle new ticket creation
  #
  # Once user selected ticket types he wans for an event
  # he cames here where he can complete his details (first_name, last_name)
  # for each ticket ordered
  def new
    @cart_data = session[:pending_cart] || {}

    if @cart_data.empty?
      redirect_to event_path(@event.slug, @event), alert: "Veuillez sélectionner au moins un billet"
      return
    end

    # Build list of tickets requiring names
    @tickets_needing_names = []
    @cart_data.each do |ticket_type_id, item|
      ticket_type = @event.ticket_types.find_by(id: ticket_type_id)
      next unless ticket_type

      quantity = item["quantity"].to_i
      next if quantity <= 0

      quantity.times do |i|
        @tickets_needing_names << {
          ticket_type_id: ticket_type.id,
          ticket_type_name: ticket_type.name,
          index: i
        }
      end
    end
  end

  # Create a new ticket
  #
  # Here new tickets are created but still in draft state.
  # When user is ready he can proceed to payment
  def create
    @cart_data = session[:pending_cart] || {}

    if @cart_data.empty?
      redirect_to event_path(params[:slug], params[:id]), alert: "Aucun billet sélectionné"
      return
    end

    @event = Event.includes(:ticket_types).find(params[:id])
    @tickets = []

    ActiveRecord::Base.transaction do
      ticket_params[:tickets_attributes]&.each do |index, ticket_attrs|
        next if ticket_attrs[:first_name].blank? || ticket_attrs[:last_name].blank?

        ticket_type = @event.ticket_types.find(ticket_attrs[:ticket_type_id])

        ticket = current_user.tickets.build(
          ticket_type: ticket_type,
          first_name: ticket_attrs[:first_name],
          last_name: ticket_attrs[:last_name],
          status: "draft"
        )

        if ticket.save
          @tickets << ticket
        else
          flash[:alert] = "Erreur lors de la création des billets: #{ticket.errors.full_messages.join(', ')}"
          raise ActiveRecord::Rollback
        end
      end

      if @tickets.present?
        session[:draft_ticket_ids] = @tickets.map(&:id)
        session.delete(:pending_cart)
        redirect_to ticket_checkout_path(@event.slug, @event.id)
      else
        flash[:alert] = "Aucun billet valide créé"
        redirect_to ticket_new_path(@event.slug, @event.id)
      end
    end
  rescue => e
    flash[:alert] = "Une erreur est survenue: #{e.message}"
    redirect_to ticket_new_path(params[:slug], params[:id])
  end

  # Display payment page
  #
  # Display a sumup of all tickets ordered by user and permit it
  # to go to payment page.
  # Here the user can pay for a ticket a bundle of tickets
  def checkout
    @event = Event.includes(:ticket_types).find(params[:id])
    draft_ticket_ids = session[:draft_ticket_ids] || []

    if draft_ticket_ids.empty?
      redirect_to event_path(@event.slug, @event), alert: "Aucun billet en attente de paiement"
      return
    end

    @tickets = current_user.tickets.includes(:ticket_type)
                           .where(id: draft_ticket_ids, status: "draft")

    if @tickets.empty?
      redirect_to event_path(@event.slug, @event), alert: "Billets non trouvés ou déjà traités"
      return
    end

    @total_amount = @tickets.sum(&:price_cents)

    # Create Stripe checkout session if Stripe is configured
    if Rails.application.config.stripe[:secret_key].present?
      begin
        @checkout_session = create_stripe_session
      rescue => e
        Rails.logger.error "Stripe checkout session creation failed: #{e.message}"
        flash[:alert] = "Erreur lors de la création de la session de paiement"
      end
    end
  end

  def show
    @ticket = current_user.tickets.includes(:ticket_type, :event).find(params[:ticket_id])
    @event = @ticket.event
  rescue ActiveRecord::RecordNotFound
    redirect_to dashboard_path, alert: "Billet non trouvé"
  end

  private

  def set_event
    @event = Event.includes(:ticket_types).find(params[:id])
  end

  def ticket_params
    params.permit(tickets_attributes: [ :ticket_type_id, :first_name, :last_name ])
  end

  def create_stripe_session
    line_items = @tickets.map do |ticket|
      {
        price_data: {
          currency: "eur",
          product_data: {
            name: "#{@event.name} - #{ticket.ticket_type.name}",
            description: ticket.ticket_type.description
          },
          unit_amount: ticket.price_cents
        },
        quantity: 1
      }
    end

    Stripe::Checkout::Session.create(
      payment_method_types: [ "card" ],
      line_items: line_items,
      mode: "payment",
      success_url: payment_success_url + "?session_id={CHECKOUT_SESSION_ID}",
      cancel_url: ticket_checkout_url(@event.slug, @event.id),
      metadata: {
        event_id: @event.id,
        user_id: current_user.id,
        ticket_ids: @tickets.pluck(:id).join(",")
      }
    )
  end
end