require "test_helper"

class TicketPdfGeneratorTest < ActiveSupport::TestCase
  def setup
    @user = User.create!(
      email: "test@example.com",
      password: "password123",
      password_confirmation: "password123"
    )

    @event = Event.create!(
      name: "Test Event",
      slug: "test-event",
      description: "A valid description for the test event that is long enough",
      latitude: 48.8566,
      longitude: 2.3522,
      venue_name: "Test Venue",
      venue_address: "123 Test Street",
      user: @user,
      start_time: 1.week.from_now,
      end_time: 1.week.from_now + 3.hours,
      state: :published
    )

    @ticket_type = TicketType.create!(
      name: "General Admission",
      description: "General admission tickets with full access to the event",
      price_cents: 2500,
      quantity: 100,
      sale_start_at: Time.current,
      sale_end_at: @event.start_time - 1.hour,
      requires_id: false,
      event: @event
    )

    @order = Order.create!(
      user: @user,
      event: @event,
      status: "paid",
      total_amount_cents: 2500
    )

    @ticket = Ticket.create!(
      order: @order,
      ticket_type: @ticket_type,
      status: "active",
      first_name: "John",
      last_name: "Doe",
      qr_code: "test-qr-code-123"
    )
  end

  # === Initialization Tests ===

  test "should initialize with ticket" do
    generator = TicketPdfGenerator.new(@ticket)
    assert_equal @ticket, generator.ticket
  end

  # === PDF Generation Tests ===

  test "should generate PDF for valid ticket" do
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    assert_not_nil pdf_string
    assert_kind_of String, pdf_string
    assert pdf_string.length > 0
    
    # Check if it starts with PDF header
    assert pdf_string.start_with?("%PDF")
  end

  test "should include event name in PDF" do
    generator = TicketPdfGenerator.new(@ticket)
    
    # Mock Prawn::Document to capture text calls
    mock_pdf = mock("pdf")
    mock_pdf.expects(:fill_color).at_least_once
    mock_pdf.expects(:font).at_least_once
    mock_pdf.expects(:text).with("ApéroNight", align: :center)
    mock_pdf.expects(:text).with(@event.name, align: :center)
    mock_pdf.expects(:move_down).at_least_once
    mock_pdf.expects(:stroke_color).at_least_once
    mock_pdf.expects(:rounded_rectangle).at_least_once
    mock_pdf.expects(:fill_and_stroke).at_least_once
    mock_pdf.expects(:text).with("Ticket Type:", style: :bold)
    mock_pdf.expects(:text).with(@ticket_type.name)
    mock_pdf.expects(:text).with("Price:", style: :bold)
    mock_pdf.expects(:text).with("€#{@ticket.price_euros}")
    mock_pdf.expects(:text).with("Date & Time:", style: :bold)
    mock_pdf.expects(:text).with(@event.start_time.strftime("%B %d, %Y at %I:%M %p"))
    mock_pdf.expects(:text).with("Venue Information")
    mock_pdf.expects(:text).with(@event.venue_name, style: :bold)
    mock_pdf.expects(:text).with(@event.venue_address)
    mock_pdf.expects(:text).with("Ticket QR Code", align: :center)
    mock_pdf.expects(:print_qr_code).once
    mock_pdf.expects(:text).with("QR Code: #{@ticket.qr_code[0..7]}...", align: :center)
    mock_pdf.expects(:horizontal_line).once
    mock_pdf.expects(:text).with("This ticket is valid for one entry only.", align: :center)
    mock_pdf.expects(:text).with("Present this ticket at the venue entrance.", align: :center)
    mock_pdf.expects(:text).with(regexp_matches(/Generated on/), align: :center)
    mock_pdf.expects(:cursor).at_least_once.returns(500)
    mock_pdf.expects(:render).returns("fake pdf content")
    
    Prawn::Document.expects(:new).with(page_size: [350, 600], margin: 20).yields(mock_pdf)
    
    pdf_string = generator.generate
    assert_equal "fake pdf content", pdf_string
  end

  test "should include ticket type information in PDF" do
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    # Basic check that PDF was generated - actual content validation
    # would require parsing the PDF which is complex
    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  test "should include price information in PDF" do
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  test "should include venue information in PDF" do
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  test "should include QR code in PDF" do
    generator = TicketPdfGenerator.new(@ticket)
    
    # Mock RQRCode to verify QR code generation
    mock_qrcode = mock("qrcode")
    RQRCode::QRCode.expects(:new).with(regexp_matches(/ticket_id.*qr_code/)).returns(mock_qrcode)
    
    pdf_string = generator.generate
    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  # === Error Handling Tests ===

  test "should raise error when QR code is blank" do
    @ticket.update!(qr_code: "")
    generator = TicketPdfGenerator.new(@ticket)

    error = assert_raises(RuntimeError) do
      generator.generate
    end

    assert_equal "Ticket QR code is missing", error.message
  end

  test "should raise error when QR code is nil" do
    @ticket.update!(qr_code: nil)
    generator = TicketPdfGenerator.new(@ticket)

    error = assert_raises(RuntimeError) do
      generator.generate
    end

    assert_equal "Ticket QR code is missing", error.message
  end

  test "should handle missing event gracefully in QR data" do
    # Create ticket without proper associations
    orphaned_ticket = Ticket.new(
      ticket_type: @ticket_type,
      status: "active",
      first_name: "John",
      last_name: "Doe",
      qr_code: "test-qr-code-123"
    )
    orphaned_ticket.save(validate: false)

    generator = TicketPdfGenerator.new(orphaned_ticket)
    
    # Should still generate PDF, but QR data will be limited
    pdf_string = generator.generate
    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  # === QR Code Data Tests ===

  test "should generate correct QR code data" do
    generator = TicketPdfGenerator.new(@ticket)
    
    expected_data = {
      ticket_id: @ticket.id,
      qr_code: @ticket.qr_code,
      event_id: @ticket.event.id,
      user_id: @ticket.user.id
    }.to_json

    # Mock RQRCode to capture the data being passed
    RQRCode::QRCode.expects(:new).with(expected_data).returns(mock("qrcode"))
    
    generator.generate
  end

  test "should compact QR code data removing nils" do
    # Test with a ticket that has some nil associations
    ticket_with_nils = @ticket.dup
    ticket_with_nils.order = nil
    ticket_with_nils.save(validate: false)
    
    generator = TicketPdfGenerator.new(ticket_with_nils)
    
    # Should generate QR data without the nil user_id
    expected_data = {
      ticket_id: ticket_with_nils.id,
      qr_code: ticket_with_nils.qr_code,
      event_id: @ticket.event.id
    }.to_json

    RQRCode::QRCode.expects(:new).with(expected_data).returns(mock("qrcode"))
    
    generator.generate
  end

  # === Price Display Tests ===

  test "should format price correctly in euros" do
    # Test different price formats
    @ticket.update!(price_cents: 1050) # €10.50
    
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    assert_not_nil pdf_string
    assert_equal 10.5, @ticket.price_euros
  end

  test "should handle zero price" do
    @ticket.update!(price_cents: 0)
    
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    assert_not_nil pdf_string
    assert_equal 0.0, @ticket.price_euros
  end

  # === Date Formatting Tests ===

  test "should format event date correctly" do
    specific_time = Time.parse("2024-12-25 19:30:00")
    @event.update!(start_time: specific_time)
    
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    # Just verify PDF generates - date formatting is handled by strftime
    assert_not_nil pdf_string
    assert pdf_string.length > 0
  end

  # === Integration Tests ===

  test "should generate valid PDF with all required elements" do
    generator = TicketPdfGenerator.new(@ticket)
    pdf_string = generator.generate

    # Basic PDF structure validation
    assert_not_nil pdf_string
    assert pdf_string.start_with?("%PDF")
    assert pdf_string.end_with?("%%EOF\n")
    assert pdf_string.length > 1000, "PDF should be substantial in size"
  end

  test "should be callable from ticket model" do
    # Test the integration with the Ticket model's to_pdf method
    pdf_string = @ticket.to_pdf
    
    assert_not_nil pdf_string
    assert pdf_string.start_with?("%PDF")
  end
end