require 'spec_helper'

describe UserSync do

  let(:user1) {FactoryGirl.create(:user)}
  let(:user2) {FactoryGirl.create(:user)}

  before(:each) do

  end

  it "empty results" do
    UserSync.all.length.should == 0
  end

  describe "index" do
    it "empty results" do
      data = UserSync.index({user_id: user1})
      data[:query].length.should == 0
      data[:next].should be_nil
    end

    it "one mix" do
      mix = FactoryGirl.create(:mix)
      mix.recording.duration = 1
      mix.recording.save!

      data = UserSync.index({user_id: mix.recording.recorded_tracks[0].user.id})
      data[:next].should be_nil
      user_syncs = data[:query]
      user_syncs.length.should == 2
      user_syncs[0].recorded_track.should == mix.recording.recorded_tracks[0]
      user_syncs[0].mix.should be_nil
      user_syncs[1].mix.should == mix
      user_syncs[1].recorded_track.should be_nil
    end

    it "two mixes, one not belonging to querier" do
      mix1 = FactoryGirl.create(:mix)
      mix2 = FactoryGirl.create(:mix)
      mix1.recording.duration = 1
      mix1.recording.save!
      mix2.recording.duration = 1
      mix2.recording.save!

      data = UserSync.index({user_id: mix1.recording.recorded_tracks[0].user.id})
      data[:next].should be_nil
      user_syncs = data[:query]
      user_syncs.length.should == 2
      user_syncs[0].recorded_track.should == mix1.recording.recorded_tracks[0]
      user_syncs[0].mix.should be_nil
      user_syncs[1].mix.should == mix1
      user_syncs[1].recorded_track.should be_nil

      data = UserSync.index({user_id: mix2.recording.recorded_tracks[0].user.id})
      data[:next].should be_nil
      user_syncs = data[:query]
      user_syncs.length.should == 2
      user_syncs[0].recorded_track.should == mix2.recording.recorded_tracks[0]
      user_syncs[0].mix.should be_nil
      user_syncs[1].mix.should == mix2
      user_syncs[1].recorded_track.should be_nil
    end

    describe "one recording with two users" do
      let!(:recording1) {
        recording = FactoryGirl.create(:recording, owner: user1, band: nil, duration:1)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: recording.owner)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: user2)
        recording.save!
        recording.reload
        recording
      }

      let(:sorted_tracks) {
        Array.new(recording1.recorded_tracks).sort! {|a, b|
          if a.created_at == b.created_at
            a.id <=> b.id
          else
            a.created_at <=> b.created_at
          end
        }
      }

      it "no claimed_recordings" do
        # both user1 and user2 should be told about each others tracks, because both will need to upload their tracks
        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 2
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]
      end

      it "recording isn't over" do
        recording1.duration = nil
        recording1.save!

        # nothing should be returned, because the recording isn't over
        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 0

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 0
      end

      it "one user decides to keep the recording" do
        claimed_recording = FactoryGirl.create(:claimed_recording, user: user1, recording: recording1, discarded:false)
        claimed_recording.recording.should == recording1

        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 2
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 2
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]
      end


      it "one user decides to discard the recording" do
        FactoryGirl.create(:claimed_recording, user: user1, recording: recording1, discarded:true)

        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 2
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 2
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]
      end

      it "both users decide to discard the recording" do
        recording1.all_discarded = true
        recording1.save!

        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 0

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 0
      end
    end

    describe "one recording with multi-track users" do
      let!(:recording1) {
        recording = FactoryGirl.create(:recording, owner: user1, band: nil, duration:1)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: recording.owner)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: recording.owner)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: user2)
        recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: user2)
        recording.save!
        recording.reload
        recording
      }

      let(:sorted_tracks) {
        Array.new(recording1.recorded_tracks).sort! {|a, b|
          if a.created_at == b.created_at
            a.id <=> b.id
          else
            a.created_at <=> b.created_at
          end
        }
      }


      it "one user decides to keep the recording" do
        claimed_recording = FactoryGirl.create(:claimed_recording, user: user1, recording: recording1, discarded:false)
        claimed_recording.recording.should == recording1

        data = UserSync.index({user_id: user1.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 4
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]
        user_syncs[2].recorded_track.should == sorted_tracks[2]
        user_syncs[3].recorded_track.should == sorted_tracks[3]

        data = UserSync.index({user_id: user2.id})
        data[:next].should be_nil
        user_syncs = data[:query]
        user_syncs.length.should == 4
        user_syncs[0].recorded_track.should == sorted_tracks[0]
        user_syncs[1].recorded_track.should == sorted_tracks[1]
        user_syncs[2].recorded_track.should == sorted_tracks[2]
        user_syncs[3].recorded_track.should == sorted_tracks[3]
      end
    end

  end

  describe "pagination" do
    let!(:recording1) {
      recording = FactoryGirl.create(:recording, owner: user1, band: nil, duration:1)
      recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: recording.owner)
      recording.recorded_tracks << FactoryGirl.create(:recorded_track, recording: recording, user: user2)
      recording.save!
      recording.reload
      recording
    }
    let(:sorted_tracks) {
      Array.new(recording1.recorded_tracks).sort! {|a, b|
        if a.created_at == b.created_at
          a.id <=> b.id
        else
          a.created_at <=> b.created_at
        end
      }
    }

    it "tiny page size" do
      # get the 1st track
      data = UserSync.index({user_id: user1.id, offset: 0, limit: 1})
      data[:next].should == 1
      user_syncs = data[:query]
      user_syncs.length.should == 1
      user_syncs[0].recorded_track.should == sorted_tracks[0]
      data[:query].total_entries.should == 2

      # then get the second track, which happens to be on an edge, pagination wise
      data = UserSync.index({user_id: user1.id, offset: 1, limit: 1})
      data[:next].should == 2
      user_syncs = data[:query]
      user_syncs.length.should == 1
      user_syncs[0].recorded_track.should == sorted_tracks[1]
      data[:query].total_entries.should == 2

      # so prove it's on the edge by asking for 2 items instead of 1.
      data = UserSync.index({user_id: user1.id, offset: 0, limit: 3})
      data[:next].should == nil
      user_syncs = data[:query]
      user_syncs.length.should == 2
      user_syncs[0].recorded_track.should == sorted_tracks[0]
      user_syncs[1].recorded_track.should == sorted_tracks[1]
      data[:query].total_entries.should == 2

      data = UserSync.index({user_id: user1.id, offset: 2, limit: 1})
      data[:next].should == nil
      user_syncs = data[:query]
      user_syncs.length.should == 0
      data[:query].total_entries.should == 2


    end
  end
end