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, :payment_success, :payment_cancel ]
  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
    error_message = e.message.present? ? e.message : "Erreur inconnue"
    flash[:alert] = "Une erreur est survenue: #{error_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")

    # Check for expired tickets and clean them up
    expired_tickets = @tickets.select(&:expired?)
    if expired_tickets.any?
      expired_tickets.each(&:expire_if_overdue!)
      @tickets = @tickets.reject(&:expired?)

      if @tickets.empty?
        session.delete(:draft_ticket_ids)
        redirect_to event_path(@event.slug, @event), alert: "Vos billets ont expiré. Veuillez recommencer votre commande."
        return
      end

      flash[:notice] = "Certains billets ont expiré et ont été supprimés de votre commande."
    end

    # Check if tickets can still be retried
    non_retryable_tickets = @tickets.reject(&:can_retry_payment?)
    if non_retryable_tickets.any?
      non_retryable_tickets.each(&:expire_if_overdue!)
      @tickets = @tickets.select(&:can_retry_payment?)

      if @tickets.empty?
        session.delete(:draft_ticket_ids)
        redirect_to event_path(@event.slug, @event), alert: "Nombre maximum de tentatives de paiement atteint. Veuillez recommencer votre commande."
        return
      end

      flash[:notice] = "Certains billets ont atteint le nombre maximum de tentatives de paiement."
    end

    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)

    # Check for expiring soon tickets
    @expiring_soon = @tickets.any?(&:expiring_soon?)

    # Create Stripe checkout session if Stripe is configured
    if Rails.application.config.stripe[:secret_key].present?
      begin
        @checkout_session = create_stripe_session
        
        # Only increment payment attempts after successfully creating the session
        @tickets.each(&:increment_payment_attempt!)
      rescue => e
        error_message = e.message.present? ? e.message : "Erreur Stripe inconnue"
        Rails.logger.error "Stripe checkout session creation failed: #{error_message}"
        flash[:alert] = "Erreur lors de la création de la session de paiement"
      end
    end
  end

  # Handle successful payment
  def payment_success
    session_id = params[:session_id]

    # Check if Stripe is properly configured
    stripe_configured = Rails.application.config.stripe[:secret_key].present?
    Rails.logger.debug "Payment success - Stripe configured: #{stripe_configured}"

    unless stripe_configured
      redirect_to dashboard_path, alert: "Le système de paiement n'est pas correctement configuré. Veuillez contacter l'administrateur."
      return
    end

    begin
      stripe_session = Stripe::Checkout::Session.retrieve(session_id)

      if stripe_session.payment_status == "paid"
        # Get event_id and ticket_ids from session metadata
        event_id = stripe_session.metadata["event_id"]
        ticket_ids_data = stripe_session.metadata["ticket_ids"]

        unless event_id.present? && ticket_ids_data.present?
          redirect_to dashboard_path, alert: "Informations de commande manquantes"
          return
        end

        # Update existing draft tickets to active
        @event = Event.find(event_id)
        ticket_ids = ticket_ids_data.split(",")
        @tickets = current_user.tickets.where(id: ticket_ids, status: "draft")

        if @tickets.empty?
          redirect_to dashboard_path, alert: "Billets non trouvés"
          return
        end

        @tickets.update_all(status: "active")

        # Send confirmation emails
        @tickets.each do |ticket|
          TicketMailer.purchase_confirmation(ticket).deliver_now
        end

        # Clear session data
        session.delete(:pending_cart)
        session.delete(:ticket_names)
        session.delete(:draft_ticket_ids)

        render "payment_success"
      else
        redirect_to dashboard_path, alert: "Le paiement n'a pas été complété avec succès"
      end
    rescue Stripe::StripeError => e
      error_message = e.message.present? ? e.message : "Erreur Stripe inconnue"
      redirect_to dashboard_path, alert: "Erreur lors du traitement de votre confirmation de paiement : #{error_message}"
    rescue => e
      error_message = e.message.present? ? e.message : "Erreur inconnue"
      Rails.logger.error "Payment success error: #{e.class} - #{error_message}"
      redirect_to dashboard_path, alert: "Une erreur inattendue s'est produite : #{error_message}"
    end
  end

  # Handle payment failure/cancellation
  def payment_cancel
    # Keep draft tickets for potential retry, just redirect back to checkout
    draft_ticket_ids = session[:draft_ticket_ids] || []

    if draft_ticket_ids.any?
      tickets = current_user.tickets.where(id: draft_ticket_ids, status: "draft")
      retryable_tickets = tickets.select(&:can_retry_payment?)

      if retryable_tickets.any?
        event = retryable_tickets.first.event
        redirect_to ticket_checkout_path(event.slug, event.id),
                   alert: "Le paiement a été annulé. Vous pouvez réessayer."
      else
        session.delete(:draft_ticket_ids)
        redirect_to dashboard_path, alert: "Le paiement a été annulé et vos billets ont expiré."
      end
    else
      redirect_to dashboard_path, alert: "Le paiement a été annulé"
    end
  end

  # Allow users to retry payment for failed/cancelled payments
  def retry_payment
    @event = Event.includes(:ticket_types).find(params[:id])
    ticket_ids = params[:ticket_ids]&.split(',') || []

    @tickets = current_user.tickets.where(id: ticket_ids)
                          .select(&:can_retry_payment?)

    if @tickets.empty?
      redirect_to event_path(@event.slug, @event),
                 alert: "Aucun billet disponible pour un nouveau paiement"
      return
    end

    # Set session for checkout
    session[:draft_ticket_ids] = @tickets.map(&:id)
    redirect_to ticket_checkout_path(@event.slug, @event.id)
  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: payment_cancel_url,
      metadata: {
        event_id: @event.id,
        user_id: current_user.id,
        ticket_ids: @tickets.pluck(:id).join(",")
      }
    )
  end
end