module JamRuby
  class MusicSessionHistory < ActiveRecord::Base

    self.table_name = "music_sessions_history"

    self.primary_key = 'id'

    belongs_to(:user, 
               :class_name => 'JamRuby::User', 
               :foreign_key => :user_id,
               :inverse_of => :music_session_histories)

    belongs_to(:band, 
               :class_name => 'JamRuby::Band', 
               :foreign_key => :band_id,                
               :inverse_of => :music_session_history)

    GENRE_SEPARATOR = '|'

    def self.index(current_user, user_id, band_id = nil, genre = nil)
      hide_private = false
      if current_user.id != user_id
        hide_private = false # TODO: change to true once public flag exists
      end

      query = MusicSessionHistory
        .joins(
          %Q{
            LEFT OUTER JOIN
              music_sessions_user_history
            ON
              music_sessions_history.music_session_id = music_sessions_user_history.music_session_id
          }
        )
        .where(
          %Q{
              music_sessions_history.user_id = '#{user_id}'
          }
        )

      #query = query.where("public = false") unless !hide_private
      query = query.where("music_sessions_history.band_id = '#{band_id}") unless band_id.nil?
      query = query.where("music_sessions_history.genres like '%#{genre}%'") unless genre.nil?
      return query
    end

    def unique_users
      User
      .joins(:music_session_user_histories)
      .group("users.id")
      .order("users.id")
      .where(%Q{ music_sessions_user_history.music_session_id = '#{music_session_id}'})
    end

    def self.save(music_session)
      session_history = MusicSessionHistory.find_by_music_session_id(music_session.id)

      if session_history.nil?
        session_history = MusicSessionHistory.new()
      end

      session_history.music_session_id = music_session.id
      session_history.description = music_session.description unless music_session.description.nil?
      session_history.user_id = music_session.creator.id
      session_history.band_id = music_session.band.id unless music_session.band.nil?
      session_history.genres = music_session.genres.map { |g| g.id }.join GENRE_SEPARATOR
      session_history.save!
    end

    def end_history
      self.update_attribute(:session_removed_at, Time.now)


      # ensure all user histories are closed
      music_session_user_histories.each do |music_session_user_history|
        music_session_user_history.end_history

        # then update any users that need their user progress updated
        if music_session_user_history.duration_minutes > 15 && music_session_user_history.max_concurrent_connections >= 3
          music_session_user_history.user.update_progression_field(:first_real_music_session_at)
        end
      end

    end

    def self.removed_music_session(session_id)
      hist = self
        .where(:music_session_id => session_id)
        .limit(1)
        .first

      hist.end_history if hist
    end

    def duration_minutes
      end_time = self.session_removed_at || Time.now
      (end_time - self.created_at) / 60.0
    end

    def music_session_user_histories
      @msuh ||= JamRuby::MusicSessionUserHistory
        .where(:music_session_id => self.music_session_id)
        .order('created_at DESC')
    end

  end
end
