jam-cloud/ruby/lib/jam_ruby/models/band_search.rb

module JamRuby
  class BandSearch < BaseSearch

    cattr_accessor :jschema, :search_meta
    attr_accessor :user_counters

    serialize :data_blob, JSON

    KEY_BAND_SEARCH_TYPE = 'band_search_type'
    KEY_BAND_STATUS = 'band_status'
    KEY_PLAY_COMMIT = 'play_commitment'
    KEY_TOUR_OPTION = 'touring_option'
    KEY_PERF_SAMPLES = 'performance_samples'
    KEY_HIRE_MAX_COST = 'max_cost'
    KEY_HIRE_FREE = 'free_gigs'

    TO_JOIN = 'to_join'
    TO_HIRE = 'to_hire'

    BAND_SEARCH_TYPE_VALS = [TO_JOIN, TO_HIRE]
    BAND_SEARCH_TYPES = {
      TO_JOIN => 'search bands',
      TO_HIRE => 'search bands to hire',
    }

    SKILL_VAL_STRS = [ANY_VAL_STR, 'amateur', 'professional']

    SORT_VALS = %W{ distance latency }
    SORT_ORDERS = { 
      SORT_VALS[0] => 'Distance to Me',
      SORT_VALS[1] => 'Latency to Me', 
    }

    HIRE_SORT_VALS = %W{ distance price_asc price_desc }
    HIRE_SORT_ORDERS = { 
      HIRE_SORT_VALS[0] => 'Distance to Me',
      HIRE_SORT_VALS[1] => 'Gig Minimum Price (Low to High)', 
      HIRE_SORT_VALS[2] => 'Gig Minimum Price (High to Low)', 
    }

    BAND_STATUS_VALS = [ANY_VAL_STR,
                     GenrePlayer::VIRTUAL_BAND,
                     GenrePlayer::TRADITIONAL_BAND,
                    ]
    BAND_STATUSS = { 
      BAND_STATUS_VALS[0] => 'Any', 
      BAND_STATUS_VALS[1] => 'Virtual Band',
      BAND_STATUS_VALS[2] => 'Traditional Band',
    }

    PLAY_COMMIT_VALS = [ANY_VAL_STR,
                        '1',
                        '2',
                        '3',
                        '4',
                       ]
    PLAY_COMMITS = { 
      PLAY_COMMIT_VALS[0] => 'Any', 
      PLAY_COMMIT_VALS[1] => 'Infrequent',
      PLAY_COMMIT_VALS[2] => 'Once a Week',
      PLAY_COMMIT_VALS[3] => '2-3 Times Per Week',
      PLAY_COMMIT_VALS[4] => '4+ Times Per Week',
    }

    TOUR_OPTION_VALS = [ANY_VAL_STR,
                        VAL_YES,
                        VAL_NO,
                       ]
    TOUR_OPTIONS = { 
      TOUR_OPTION_VALS[0] => 'Any', 
      TOUR_OPTION_VALS[1] => VAL_YES,
      TOUR_OPTION_VALS[2] => VAL_NO,
    }

    PERF_SAMPLES_VALS = TOUR_OPTION_VALS.clone
    PERF_SAMPLES = TOUR_OPTIONS.clone 

    def self.json_schema
      return @@jschema if @@jschema
      @@jschema = {
        TO_JOIN => BaseSearch.json_schema.merge({
          KEY_SKILL => self::SKILL_VAL_STRS[0].to_s,
          KEY_BAND_STATUS => BAND_STATUS_VALS[0],
          KEY_PLAY_COMMIT => PLAY_COMMIT_VALS[0],
          KEY_TOUR_OPTION => TOUR_OPTION_VALS[0],
        }),
        TO_HIRE => {
          KEY_SORT_ORDER => self::HIRE_SORT_VALS[0],
          KEY_GENRES => [],
          KEY_SKILL => self::SKILL_VAL_STRS[0].to_s,
          KEY_GIGS => self::GIG_COUNTS[0].to_s,
          KEY_PERF_SAMPLES => self::PERF_SAMPLES[0].to_s,
          KEY_HIRE_MAX_COST => 0,
          KEY_HIRE_FREE => 1,
        },
      }
    end

    def self.search_filter_meta
      return @@search_meta if @@search_meta
      toJoinMeta = super(self.json_schema[TO_JOIN])
      toJoinMeta.merge!({ 
                          KEY_BAND_STATUS => { keys: BAND_STATUS_VALS, map: BAND_STATUSS },
                          KEY_PLAY_COMMIT => { keys: PLAY_COMMIT_VALS, map: PLAY_COMMITS },
                          KEY_TOUR_OPTION => { keys: TOUR_OPTION_VALS, map: TOUR_OPTIONS } 
                        })
      toHireMeta = super(self.json_schema[TO_HIRE],
                         { keys: HIRE_SORT_VALS, map: HIRE_SORT_ORDERS })
      toHireMeta.merge!({
                          KEY_PERF_SAMPLES => { keys: PERF_SAMPLES_VALS, map: PERF_SAMPLES },
                        })
      @@search_meta = {
        TO_JOIN => toJoinMeta,
        TO_HIRE => toHireMeta,
      }
    end

    def self.search_target_class
      Band
    end

    def _sort_order(rel, filter)
      rel
    end

    def _genres(rel, filter)
      super(rel, filter)
    end

    def _concert_gigs(rel, filter)
      gg = filter[KEY_GIGS].to_i
      rel = rel.where(concert_count: gg) if 0 <= gg
      rel
    end

    def _band_status(rel, filter)
      case filter[KEY_BAND_STATUS]
        when GenrePlayer::VIRTUAL_BAND 
          rel.where(band_status: GenrePlayer::VIRTUAL_BAND.sub('_band',''))
        when GenrePlayer::TRADITIONAL_BAND
          rel.where(band_status: GenrePlayer::TRADITIONAL_BAND.sub('_band',''))
        else
          rel
      end
    end

    def _play_commitment(rel, filter)
      unless ANY_VAL_STR == filter[KEY_PLAY_COMMIT]
        rel = rel.where(play_commitment: filter[KEY_PLAY_COMMIT].to_i)
      end
      rel
    end

    def _touring_option(rel, filter)
      case filter[KEY_TOUR_OPTION]
        when VAL_YES
          rel.where(touring_option: true)
        when VAL_NO
          rel.where(touring_option: false)
        else
          rel
      end
    end

    def _performance_samples(rel, filter)
      case filter[KEY_PERF_SAMPLES]
        when VAL_YES
          rel.joins("LEFT OUTER JOIN performance_samples AS ps ON ps.player_id = bands.id AND player_type = '#{self.class.name}'").where(["ps.id IS NOT NULL"])
        when VAL_NO
          rel.joins("LEFT OUTER JOIN performance_samples AS ps ON ps.player_id = bands.id AND player_type = '#{self.class.name}'").where(["ps.id IS NULL"])
        else
          rel
      end
    end

    def _max_cost(rel, filter)
      if 0 < (max_cost = filter[KEY_HIRE_MAX_COST].to_i)
        col = Band.arel_table[:gig_minimum]
        rel = rel.where(col.lteq(max_cost)).where(col.gt(0))
      end
      rel
    end

    def _free_gigs(rel, filter)
      case filter[KEY_HIRE_FREE]
        when VAL_YES
          rel.where(free_gigs: true)
        when VAL_NO
          rel.where(free_gigs: false)
        else
          rel
      end
    end

    def _skill_level(rel, filter)
      case filter[KEY_SKILL]
        when SKILL_VAL_STRS[1]
          rel.where(band_type: SKILL_VAL_STRS[1])
        when SKILL_VAL_STRS[2]
          rel.where(band_type: SKILL_VAL_STRS[2])
        else
          rel
      end
    end

    def do_search(filter)
      rel = Band.unscoped
      filter.keys.each do |fkey| 
        mname = "_#{fkey}"
        if self.respond_to?(mname)
          rel = self.send(mname.to_sym, rel, filter) 
        end
      end
      rel
    end

    def search_includes(rel)
      rel.includes([:instruments])
    end

    def process_results_page(_results)
      @results = _results
      if user
        @user_counters = @results.inject({}) { |hh,val| hh[val.id] = []; hh }
        mids = "'#{@results.map(&:id).join("','")}'"

        # this gets counts for each search result 
        @results.each do |bb|
          counters = { }
          @user_counters[bb.id] << counters
        end
      else
        @user_counters = {}
      end
      self
    end

    private 

    def _count(musician, key)
      if mm = @user_counters[musician.id] 
        return mm.detect { |ii| ii.is_a?(Hash) }[key]
      end if @user_counters
      0
    end

    public

    def follow_count(musician)
      _count(musician, COUNT_FOLLOW)
    end

    def friend_count(musician)
      _count(musician, COUNT_FRIEND)
    end

    def record_count(musician)
      _count(musician, COUNT_RECORD)
    end

    def session_count(musician)
      _count(musician, COUNT_SESSION)
    end

    def is_friend?(musician)
      if mm = @user_counters[musician.id] 
        return mm.include?(RESULT_FRIEND)
      end if @user_counters
      false
    end

    def is_follower?(musician)
      if mm = @user_counters[musician.id] 
        return mm.include?(RESULT_FOLLOW)
      end if @user_counters
      false
    end

    def search_type
      self.class.to_s
    end

    def is_blank?
      self.data_blob == self.class.json_schema
    end

    def description
      if self.is_blank?
        return 'Click search button to look for musicians with similar interests, skill levels, etc.'
      end
      jj = self.json
      str = 'Current Search: '
      str += "Sort = #{SORT_ORDERS[json_value(BandSearch::KEY_SORT_ORDER)]}"
      str
    end

    def reset_filter(subtype, data=nil)
      data ||= self.class.json_schema[subtype]
      dblob = self.data_blob
      dblob[subtype] = data
      self.data_blob = dblob
      self.save
    end

    def reset_search_results(subtype=TO_JOIN)
      reset_filter(subtype)
      search_results_page(subtype)
    end

    def self.search_filter_json(user, subtype=TO_JOIN)
      self.user_search_filter(user).json[subtype]
    end

    def search_filter_for_subtype(subtype)
      self.data_blob[subtype]
    end

    def search_results_page(subtype=TO_JOIN, filter=nil, page=1)
      if filter
        reset_filter(subtype, filter)
      else
        filter = self.search_filter_for_subtype(subtype)
      end
      rel = do_search(filter)

      @page_number = [page.to_i, 1].max
      rel = rel.paginate(:page => @page_number, :per_page => self.class::PER_PAGE)

      rel = self.search_includes(rel)
      @page_count = rel.total_pages

      process_results_page(rel.all)
    end
    
  end
end