require 'rails_helper'

RSpec.describe Core::Event, type: :model do
  it 'has a valid factory' do
    expect(create(:core_event)).to be_valid
  end

  it 'is invalid without a name' do
    expect(build(:core_event, name: nil)).to be_invalid
  end

  it 'is invalid without a start_time' do
    expect(build(:core_event, start_time: nil)).to be_invalid
  end

  it 'is invalid without an end_time' do
    expect(build(:core_event, end_time: nil)).to be_invalid
  end

  it 'is invalid without a price' do
    expect(build(:core_event, price: nil)).to be_invalid
  end

  it 'has a list of possible availability types' do
    expect(described_class.availabilities).to eq %w(unknown spaces full
                                                    waitlist)
  end

  it 'can have an availability status of full' do
    expect(build(:core_event, availability: 'full')).to be_valid
  end

  it 'refuses invalid availabilities' do
    expect(build(:core_event, availability: 'something')).to be_invalid
  end

  it 'can be discovered by availability' do
    5.times { create(:core_event, availability: 'full') }

    expect(described_class.where(availability: 'full').count).to eq 5
  end

  it 'can have an external_id' do
    event = create(:core_event, external_id: 'abc')

    expect(event.external_id).to eq 'abc'
  end

  it 'has an associated organisation' do
    event = create(:core_event)

    expect(event.organisation).to be_an_instance_of(Core::Organisation)
  end

  it 'has an associated venue' do
    event = create(:core_event)

    expect(event.venue).to be_an_instance_of(Core::Venue)
  end

  it 'creates an organisation venue to hold the location' do
    organisation = create(:core_organisation)
    venue = create(:core_venue)

    event = create(:core_event, organisation: organisation, venue: venue)

    expect(event).not_to be_nil
    expect(event.organisation).not_to be_nil
    expect(event.venue).not_to be_nil

    ov_where = Core::OrganisationVenue.where(organisation: organisation,
                                             venue: venue)
    expect(ov_where).not_to eq []
  end

  it 'can have multiple instructors' do
    event = create(:core_event)
    instructor = create(:core_instructor)
    event.instructors = [instructor]

    expect(event.instructors).to eq([instructor])
  end

  it 'can have multiple activity_types' do
    event = create(:core_event)
    event.activity_types = ['yoga']

    expect(event.activity_types).to eq(['yoga'])
  end

  it 'accepts nested parameters for instructors' do
    event = create(:core_event)

    event.update_attributes(
      instructors_attributes: [{ name: 'Teacher',
                                 organisation: event.organisation }])

    expect(event.instructors.count).to eq 1
  end

  it 'can be sorted by location through the venue' do
    # venues
    parliament = create(:core_venue, name: 'Big Ben', latitude: '51.499167',
                                     longitude: '-0.124722')
    st_thomas_hospital = create(:core_venue, name: "St. Thomas' Hospital",
                                             latitude: '51.4991',
                                             longitude: '-0.11891')

    event_one = create(:core_event, venue: parliament)
    event_two = create(:core_event, venue: st_thomas_hospital)

    # westminster tube
    pin = { latitude: '51.501', longitude: '-0.125' }

    events = described_class.close_to(pin[:latitude], pin[:longitude])

    expect(events).to eq([event_one, event_two])
  end

  it 'can be sorted by location through the venue and limited in distance' do
    # venues
    parliament = create(:core_venue, name: 'Big Ben', latitude: '51.499167',
                                     longitude: '-0.124722')
    st_thomas_hospital = create(:core_venue, name: "St. Thomas' Hospital",
                                             latitude: '51.4991',
                                             longitude: '-0.11891')

    event_one = create(:core_event, venue: parliament)
    create(:core_event, venue: st_thomas_hospital)

    # westminster tube
    pin = { latitude: '51.501', longitude: '-0.125' }

    events = described_class.close_to(pin[:latitude], pin[:longitude], 300)

    expect(events).to eq([event_one])
  end

  it 'can be searched through the name, description and instructor' do
    event_one = create(:core_event, name: 'Simple Class',
                                    description: 'This is a simple class')
    create(:core_event, name: 'Advanced Class',
                        description: 'This is an advanced class')

    events = described_class.search('simple')

    expect(events.count(:all)).to eq 1
    expect(events).to eq [event_one]
  end

  it 'cannot be deleted if it has associated bookings' do
    event = create(:core_event)
    user = create(:core_user)
    create(:core_booking, event: event, user: user)

    event.destroy

    expect(event.destroyed?).to be_falsey
  end
end