module Connectors
  class Statistic < Base

    def initialize(db)
      super(db)
    end

    def collection_name
      'statistic'
    end

    def insert_statistic(user, path, method, body, response_code)
      collection.insert(user: user, path: path, method: method, body: body, response_code: response_code, date: Time.now)
    end

    # supported options:
    #   user
    #   response_code (format: 200)
    #   method
    #   path_equal
    #   path_contains
    #   date_from (format: 2014-12-01 09:18:40 UTC)
    #   date_till (format: 2014-12-01 09:18:40 UTC)
    #   limit: default 20. Zero value is equal to no limit.
    #   sort_field: default 'date'. Could also be in [user, path, method, body, response_code, date].
    #   sort_order: default 'asc'. Could also be 'desc'
    def search_statistic(filters={})
      limit = filters[:limit] || 20
      sort_field = filters[:sort_field] || 'date'
      sort_order = mongo_sort_order(filters[:sort_order] || 'asc')
      query = {}


      query.deep_merge!( user_equal(filters[:user])) if filters[:user]
      query.deep_merge!( method_equal(filters[:method])) if filters[:method]
      query.deep_merge!( response_code_equal(filters[:response_code])) if filters[:response_code]
      query.deep_merge!( path_equal(filters[:path_equal])) if filters[:path_equal]
      query.deep_merge!( path_contains(filters[:path_contains])) if filters[:path_contains]
      query.deep_merge!( date_from(filters[:date_from])) if filters[:date_from]
      query.deep_merge!( date_till(filters[:date_till])) if filters[:date_till]

      collection.
        find(query, fields: {"_id" => false}).
        limit(limit.to_i).
        sort(sort_field => sort_order).
        to_a
    end

    private

      def mongo_sort_order(order)
        # asc by default and if order id invalid value, it is not a reason for response with code 500
        #raise "Wrong sort order" unless %w(asc desc).include?(order)
        order == 'asc' ? 1 : -1
      end

      def user_equal(user)
        {user: user}
      end

      def method_equal(method)
        {method: method}
      end

      def path_contains(path)
        {path: Regexp.new(path, 'i')}
      end

      def path_equal(path)
        {path: path}
      end

      def response_code_equal(response_code)
        {response_code: response_code.to_i}
      end

      def date_from(date)
        {date: {'$gte' => Time.parse(date)}}
      end

      def date_till(date)
        {date: {'$lte' => Time.parse(date)}}
      end

  end
end