require 'faker'

module Test
  module Unit
    module Given
      # Public: Provides the ability to vend arbitrary values without using literals, or
      # long calls to Faker.  This has two levels of utility:
      #
      # helper methods - #any_number, #any_int, #any_string provide arbitrary primitives 
      #                  to make it clear what numbers, ints, and strings in your tests are
      #                  relevant.  Arbitrary values should use one of these any_ helpers.
      #
      # any sort of any - you can define your own "any" values by using #new_any, which allows you to 
      #                   extend things if you like.  Of course, you could just make your own any_method as well.
      module Any
        MAX_RAND = 50000

        # Public: Get any number; one that doesn't matter
        #
        # options - options to control what sort of number comes back:
        #           :positive - make sure that the number is greater than zero
        #           :negative - make sure that the number is less than zero
        def any_number(*options)
          any :number,options
        end

        # Public: Returns an integer.  options is the same as for #any_number
        def any_int(*options)
          any :int,options
        end

        # Public: Get an arbitrary string of any potential length (the real max is 2048 characters if you don't override it)
        #
        # options - options to control the returned string
        #           :max the max size of the string you want
        #           :min the minimum size we want to come back
        #
        # Example
        #
        #     any_string :max => 255 # => ensure it'll fit into a varchar(255)
        #     any_string :min => 1024 # at least 1024 characters
        #
        def any_string(options = {})
          any :string,options
        end

        # Public: Get a predefined, arbitrary any.  
        #
        # sym - the any that has been defined already.  By default, the following are defined:
        #       :string - does any_string
        #       String  - does any_string
        #       :number  - does any_number
        #       Numeric  - does any_number
        #       Float  - does any_number
        #       :int  - does any_int
        #       Fixnum  - does any_int
        #       Integer  - does any_int
        # options - whatever options are relevant to the user-defined any
        #
        # Example
        #
        #     new_any(:foo) do |options|
        #       if options[:bar]
        #         'bar'
        #       else
        #         'quux'
        #       end
        #     end
        #
        #     some_foo = any :foo
        #     some_other_foo = any :foo, :bar => true
        def any(sym,options = {})
          anies[sym].call(options)
        end

        # Public: Create a new any that can be retrieved via #any
        #
        # any - the identifer of your new any. Can be anything though a Symbol or classname would be appropriate
        # block - the block that will be called whenever you #any your any.
        def new_any(any,&block)
          anies[any] = block
        end

        private

        def anies
          @anies ||= default_anies
        end

        ANY_STRING = Proc.new do |options|
          max_size = options[:max] || rand(2048)
          min_size = options[:min] || rand(1024)
          min_size = max_size if min_size > max_size

          size = rand(max_size)

          size = min_size if size < min_size

          string = Faker::Lorem.words(1).join('')
          while string.length < size
            string += Faker::Lorem.words(1).join('') 
          end

          string[0..(max_size-1)]
        end

        ANY_NUMBER = Proc.new do |options|
          number = (rand(2 * MAX_RAND) - MAX_RAND).to_f/100.0
          if options.include? :positive
            number + MAX_RAND
          elsif options.include? :negative
            number - MAX_RAND
          else
            number
          end
        end

        ANY_INT = Proc.new do |options|
          (ANY_NUMBER.call(options)).to_i
        end

        def default_anies
          { :string => ANY_STRING,
            String => ANY_STRING,
            :number => ANY_NUMBER,
            Numeric => ANY_NUMBER,
            Float => ANY_NUMBER,
            :int => ANY_INT,
            Fixnum => ANY_INT,
            Integer => ANY_INT,
          }
        end
      end
    end
  end
end