require 'spec_helper'

describe 'Musician search' do

  before(:each) do
    @geocode1 = FactoryGirl.create(:geocoder)
    @geocode2 = FactoryGirl.create(:geocoder)
    @users = []
    @users << @user1 = FactoryGirl.create(:user)
    @users << @user2 = FactoryGirl.create(:user)
    @users << @user3 = FactoryGirl.create(:user)
    @users << @user4 = FactoryGirl.create(:user)
  end

  context 'default filter settings' do 

    it "finds all musicians" do
      # expects all the users
      num = User.musicians.count
      results = Search.musician_filter({ :per_page => num })
      expect(results.results.count).to eq(num)
      expect(results.search_type).to be(:musicians_filter)
    end

    it "finds musicians with proper ordering" do
      # the ordering should be create_at since no followers exist
      expect(Follow.count).to eq(0)
      results = Search.musician_filter({ :per_page => User.musicians.count })
      results.results.each_with_index do |uu, idx|
        expect(uu.id).to eq(@users.reverse[idx].id)
      end
    end

    it "sorts musicians by followers" do
      # establish sorting order

      # @user4
      f1 = Follow.new
      f1.user = @user2
      f1.followable = @user4
      f1.save

      f2 = Follow.new
      f2.user = @user3
      f2.followable = @user4
      f2.save

      f3 = Follow.new
      f3.user = @user4
      f3.followable = @user4
      f3.save

      # @user3
      f4 = Follow.new
      f4.user = @user3
      f4.followable = @user3
      f4.save

      f5 = Follow.new
      f5.user = @user4
      f5.followable = @user3
      f5.save

      # @user2
      f6 = Follow.new
      f6.user = @user1
      f6.followable = @user2
      f6.save

      # @user4.followers.concat([@user2, @user3, @user4])
      # @user3.followers.concat([@user3, @user4])
      # @user2.followers.concat([@user1])
      expect(@user4.followers.count).to be 3
      expect(Follow.count).to be 6

      # refresh the order to ensure it works right
      f1 = Follow.new
      f1.user = @user3
      f1.followable = @user2
      f1.save

      f2 = Follow.new
      f2.user = @user4
      f2.followable = @user2
      f2.save

      f3 = Follow.new
      f3.user = @user2
      f3.followable = @user2
      f3.save

      # @user2.followers.concat([@user3, @user4, @user2])
      results = Search.musician_filter({ :per_page => @users.size }, @user3)
      expect(results.results[0].id).to eq(@user2.id)

      # check the follower count for given entry
      expect(results.results[0].search_follow_count.to_i).not_to eq(0)
      # check the follow relationship between current_user and result
      expect(results.is_follower?(@user2)).to be true
    end

    it 'paginates properly' do 
      # make sure pagination works right
      params = { :per_page => 2, :page => 1 }
      results = Search.musician_filter(params)
      expect(results.results.count).to be 2
    end

  end

  def make_recording(usr)
    connection = FactoryGirl.create(:connection, :user => usr)
    instrument = FactoryGirl.create(:instrument, :description => 'a great instrument')
    track = FactoryGirl.create(:track, :connection => connection, :instrument => instrument)
    music_session = FactoryGirl.create(:active_music_session, :creator => usr, :musician_access => true)
    # music_session.connections << connection
    music_session.save
    connection.join_the_session(music_session, true, nil)
    recording = Recording.start(music_session, usr)
    recording.stop
    recording.reload
    genre = FactoryGirl.create(:genre)
    recording.claim(usr, "name", "description", genre, true)
    recording.reload
    recording
  end

  def make_session(usr)
    connection = FactoryGirl.create(:connection, :user => usr)
    music_session = FactoryGirl.create(:active_music_session, :creator => usr, :musician_access => true)
    # music_session.connections << connection
    music_session.save
    connection.join_the_session(music_session, true, nil)
  end

  context 'musician stat counters' do

    it "displays musicians top followings" do
      f1 = Follow.new
      f1.user = @user4
      f1.followable = @user4
      f1.save

      f2 = Follow.new
      f2.user = @user4
      f2.followable = @user3
      f2.save

      f3 = Follow.new
      f3.user = @user4
      f3.followable = @user2
      f3.save

      # @user4.followers.concat([@user4])
      # @user3.followers.concat([@user4])
      # @user2.followers.concat([@user4])
      expect(@user4.top_followings.count).to be 3
      expect(@user4.top_followings.map(&:id)).to match_array((@users - [@user1]).map(&:id))
    end

    it "friends stat shows friend count" do
      # create friendship record
      Friendship.save(@user1.id, @user2.id)
      # search on user2
      results = Search.musician_filter({}, @user2)
      friend = results.results.detect { |mm| mm.id == @user1.id }
      expect(friend).to_not be_nil
      expect(results.friend_count(friend)).to be 1
      @user1.reload
      expect(friend.friends?(@user2)).to be true
      expect(results.is_friend?(@user1)).to be true
    end

    it "recording stat shows recording count" do
      recording = make_recording(@user1)
      expect(recording.users.length).to be 1
      expect(recording.users.first).to eq(@user1)
      @user1.reload
      expect(@user1.recordings.length).to be 1
      expect(@user1.recordings.first).to eq(recording)
      expect(recording.claimed_recordings.length).to be 1
      expect(@user1.recordings.detect { |rr| rr == recording }).to_not be_nil

      results = Search.musician_filter({},@user1)
      uu = results.results.detect { |mm| mm.id == @user1.id }
      expect(uu).to_not be_nil

      expect(results.record_count(uu)).to be 1
      expect(results.session_count(uu)).to be 1
    end

  end

  context 'musician sorting' do 

    it "by plays" do
      make_recording(@user1)
      # order results by num recordings
      results = Search.musician_filter({ :orderby => 'plays' }, @user2)
      expect(results.results[0].id).to eq(@user1.id)

      # add more data and make sure order still correct
      make_recording(@user2); make_recording(@user2)
      results = Search.musician_filter({ :orderby => 'plays' }, @user2)
      expect(results.results[0].id).to eq(@user2.id)
    end

    it "by now playing" do
      # should get 1 result with 1 active session
      make_session(@user3)
      results = Search.musician_filter({ :orderby => 'playing' }, @user2)
      expect(results.results.count).to be 1
      expect(results.results.first.id).to eq(@user3.id)

      # should get 2 results with 2 active sessions
      # sort order should be created_at DESC
      make_session(@user4)
      results = Search.musician_filter({ :orderby => 'playing' }, @user2)
      expect(results.results.count).to be 2
      expect(results.results[0].id).to eq(@user4.id)
      expect(results.results[1].id).to eq(@user3.id)
    end

  end

  context 'filter settings' do 
    it "searches musicisns for an instrument" do
      minst = FactoryGirl.create(:musician_instrument, { 
                                   :user => @user1,
                                   :instrument => Instrument.find('tuba') })
      @user1.musician_instruments << minst
      @user1.reload
      ii = @user1.instruments.detect { |inst| inst.id == 'tuba' }
      expect(ii).to_not be_nil
      results = Search.musician_filter({ :instrument => ii.id })
      results.results.each do |rr|
        expect(rr.instruments.detect { |inst| inst.id=='tuba' }.id).to eq(ii.id)
      end
      expect(results.results.count).to be 1
    end

    it "finds musicians within a given distance of given location" do
      pending 'distance search changes'
      num = User.musicians.count
      expect(@user1.lat).to_not be_nil
      # short distance
      results = Search.musician_filter({ :per_page => num, 
                                         :distance => 10, 
                                         :city => 'Apex' }, @user1)
      expect(results.results.count).to be num
      # long distance
      results = Search.musician_filter({ :per_page => num,
                                         :distance => 1000, 
                                         :city => 'Miami', 
                                         :state => 'FL' }, @user1)
      expect(results.results.count).to be num
    end

    it "finds musicians within a given distance of users location" do
      pending 'distance search changes'
      expect(@user1.lat).to_not be_nil
      # uses the location of @user1
      results = Search.musician_filter({ :distance => 10, :per_page => User.musicians.count }, @user1)
      expect(results.results.count).to be User.musicians.count
    end

    it "finds no musicians within a given distance of location" do
      pending 'distance search changes'
      expect(@user1.lat).to_not be_nil
      results = Search.musician_filter({ :distance => 10, :city => 'San Francisco' }, @user1)
      expect(results.results.count).to be 0
    end

  end

  context 'new users' do

    it "find nearby" do
      # create new user outside 500 from Apex to ensure its excluded from results
      FactoryGirl.create(:user, {city: "Austin", state: "TX", country: "US"})
      User.geocoded_users.find_each do |usr|
        Search.new_musicians(usr) do |new_usrs|
          # the newly created user is not nearby the existing users (which are in Apex, NC)
          # and that user is not included in query 
          expect(new_usrs.count).to eq(User.musicians.count - 1)
        end
      end
    end

    it "sends new musician email" do
      # create new user outside 500 from Apex to ensure its excluded from results
      FactoryGirl.create(:user, {city: "Austin", state: "TX", country: "US"})
      User.geocoded_users.find_each do |usr|
        Search.new_musicians(usr) do |new_usrs|
          # the newly created user is not nearby the existing users (which are in Apex, NC)
          # and that user is not included in query 
          expect(new_usrs.count).to eq(User.musicians.count - 1)
        end
      end
    end

  end

end