require 'rspec'
require 'date'

module Airborne
  module RequestExpectations
    include RSpec
    include PathMatcher

    def expect_json_types(*args)
      call_with_path(args) do |param, body|
        expect_json_types_impl(param, body)
      end
    end

    def expect_json(*args)
      call_with_path(args) do |param, body|
        expect_json_impl(param, body)
      end
    end

    def expect_json_keys(*args)
      call_with_path(args) do |param, body|
        expect(body.keys).to include(*param)
      end
    end

    def expect_json_sizes(*args)
      args.push(convert_expectations_for_json_sizes(args.pop))

      expect_json_types(*args)
    end

    def expect_status(code)
      expect(response.code).to eq(code)
    end

    def expect_header(key, content)
      expect_header_impl(key, content)
    end

    def expect_header_contains(key, content)
      expect_header_impl(key, content, true)
    end

    def optional(hash)
      OptionalHashTypeExpectations.new(hash)
    end

    def regex(reg)
      Regexp.new(reg)
    end

    def date
      lambda {|value| yield DateTime.parse(value)}
    end

    [:expect_json_types, :expect_json, :expect_json_keys, :expect_status, :expect_header, :expect_header_contains].each do |method_name|
      method = instance_method(method_name)
      define_method(method_name) do |*args, &block|
        set_rails_response
        method.bind(self).(*args, &block)
      end
    end

    private

    def expect_header_impl(key, content, contains = nil)
      header = headers[key]
      if header
        if contains
          expect(header.downcase).to include(content.downcase)
        else
          expect(header.downcase).to eq(content.downcase)
        end
      else
        raise RSpec::Expectations::ExpectationNotMetError, "Header #{key} not present in HTTP response"
      end
    end

    def set_rails_response
      set_response(@response) if @json_body.nil?
    end

    def call_with_path(args)
      if args.length == 2
        get_by_path(args[0], json_body) do|json_chunk|
          yield(args[1], json_chunk)
        end
      else
        yield(args[0], json_body)
      end
    end

    def get_mapper
      base_mapper = {
        integer: [Fixnum,Bignum],
        array_of_integers: [Fixnum,Bignum],
        int: [Fixnum,Bignum],
        array_of_ints: [Fixnum,Bignum],
        float: [Float,Fixnum,Bignum],
        array_of_floats: [Float,Fixnum,Bignum],
        string: [String],
        array_of_strings: [String],
        boolean: [TrueClass, FalseClass],
        array_of_booleans: [TrueClass, FalseClass],
        bool: [TrueClass, FalseClass],
        array_of_bools: [TrueClass, FalseClass],
        object: [Hash],
        array_of_objects: [Hash],
        array: [Array],
        array_of_arrays: [Array],
        date: [DateTime]
      }

      mapper = base_mapper.clone
      base_mapper.each do |key, value|
        mapper[(key.to_s + "_or_null").to_sym] = value + [NilClass]
      end
      mapper
    end

    def expect_json_types_impl(expectations, hash_or_value)
      return if is_nil_optional_hash?(expectations, hash_or_value)

      @mapper ||= get_mapper

      hash_or_value = convert_to_date(hash_or_value) if expectations == :date

      return expect_type(expectations, hash_or_value.class) if expectations.class == Symbol
      return expectations.call(hash_or_value) if expectations.class == Proc

      expectations.each do |prop_name, expected_type|
        value = expected_type == :date ? convert_to_date(hash_or_value[prop_name]) : hash_or_value[prop_name]
        expected_class = expected_type.class
        value_class = value.class

        next expect_json_types_impl(expected_type, value) if is_hash?(expected_class)
        next expected_type.call(value) if expected_class == Proc

        if expected_type.to_s.include?("array_of")
          check_array_types(value, value_class, prop_name, expected_type)
        else
          expect_type(expected_type, value_class, prop_name)
        end
      end
    end

    def convert_to_date(value)
      begin
        value = DateTime.parse(value)
      rescue
      end
    end

    def check_array_types(value, value_class, prop_name, expected_type)
      expect_array(value_class, prop_name, expected_type)
      value.each do |val|
        expect_type(expected_type, val.class, prop_name)
      end
    end

    def is_nil_optional_hash?(expectations, hash)
      expectations.class == Airborne::OptionalHashTypeExpectations && hash.nil?
    end

    def expect_type(expected_type, value_class, prop_name = nil)
      insert = prop_name.nil? ? "" : "#{prop_name} to be of type"
      msg = "Expected #{insert} #{expected_type}\n, got #{value_class} instead"
      expect(@mapper[expected_type].include?(value_class)).to eq(true), msg
    end

    def is_hash?(expected_class)
      expected_class == Hash || expected_class ==  Airborne::OptionalHashTypeExpectations
    end

    def expect_array(value_class, prop_name, expected_type)
      expect(value_class).to eq(Array), "Expected #{prop_name}\n to be of type #{expected_type}\n, got #{value_class} instead"
    end

    def expect_json_impl(expectations, hash)
      hash = hash.to_s if expectations.class == Regexp
      return expect(hash).to match(expectations) if is_property?(expectations)
      expectations.each do |prop_name, expected_value|
        actual_value = hash[prop_name]
        expected_class = expected_value.class
        next expect_json_impl(expected_value, actual_value) if expected_class == Hash
        next expected_value.call(actual_value) if expected_class == Proc
        next expect(actual_value.to_s).to match(expected_value) if expected_class == Regexp
        expect(actual_value).to eq(expected_value)
      end
    end

    # Convert integers in `old_expectations` to proc
    #
    # @param old_expectations [Hash]
    def convert_expectations_for_json_sizes(old_expectations)
      unless old_expectations.is_a?(Hash)
        return convert_expectation_for_json_sizes(old_expectations)
      end

      old_expectations.each_with_object({}) do |(prop_name, expected_size), memo|
        new_value = if expected_size.is_a?(Hash)
                      convert_expectations_for_json_sizes(expected_size)
                    else
                      convert_expectation_for_json_sizes(expected_size)
                    end
        memo[prop_name] = new_value
      end
    end

    # @param expected_size [Integer]
    # @return [Proc]
    def convert_expectation_for_json_sizes(expected_size)
      -> (data) { expect(data.size).to eq(expected_size) }
    end

    def is_property?(expectations)
      [String, Regexp, Float, Fixnum, Bignum, TrueClass, FalseClass, NilClass].include?(expectations.class)
    end

  end
end