# 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, :create ]

  # 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 d'abord sélectionner vos billets sur la page de l'événement"
      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 order with tickets
  #
  # Here a new order is created with associated tickets in draft state.
  # When user is ready they can proceed to payment via the order checkout
  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])
    success = false
    
    ActiveRecord::Base.transaction do
      @order = current_user.orders.create!(event: @event, status: "draft")

      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 = @order.tickets.build(
          ticket_type: ticket_type,
          first_name: ticket_attrs[:first_name],
          last_name: ticket_attrs[:last_name],
          status: "draft"
        )

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

      if @order.tickets.present?
        @order.calculate_total!
        success = true
      else
        flash[:alert] = "Aucun billet valide créé"
        raise ActiveRecord::Rollback
      end
    end
    
    # Handle redirects outside transaction
    if success
      session[:draft_order_id] = @order.id
      session.delete(:pending_cart)
      redirect_to checkout_order_path(@order)
    else
      redirect_to ticket_new_path(@event.slug, @event.id)
    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

  # Redirect to order-based checkout
  def checkout
    # Check for draft order
    if session[:draft_order_id].present?
      order = current_user.orders.find_by(id: session[:draft_order_id], status: "draft")
      if order.present?
        redirect_to order_checkout_path(order)
        return
      end
    end

    # No order found
    @event = Event.includes(:ticket_types).find(params[:id])
    redirect_to event_path(@event.slug, @event), alert: "Aucun billet en attente de paiement"
  end

  # Redirect to order-based payment success
  def payment_success
    redirect_to order_payment_success_path(session_id: params[:session_id])
  end

  # Redirect to order-based payment cancel
  def payment_cancel
    redirect_to order_payment_cancel_path
  end

  # Redirect retry payment to order system
  def retry_payment
    @event = Event.includes(:ticket_types).find(params[:id])
    
    # Look for draft order for this event
    order = current_user.orders.find_by(event: @event, status: "draft")
    
    if order&.can_retry_payment?
      redirect_to retry_payment_order_path(order)
    else
      redirect_to event_path(@event.slug, @event),
                 alert: "Aucune commande disponible pour un nouveau paiement"
    end
  end

  def show
    @ticket = current_user.orders.joins(:tickets).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