module Eco
  module API
    class UseCases
      class OozeSamples
        module Helpers
          module Shortcuts
            # Basic simplification pattern (matches all but a-z and blank space)
            def non_letters_regex
              @non_letters_regex ||= /[^a-z ]+/
            end

            # Matches anything between two consecutive (), inclusive
            def bracked_regex
              @bracked_regex ||= /(?<bracked>\([^\)]+?\))/
            end

            # It always downcase, trim and remove double spaces.
            # @param ignore Boolean, Regexp] ingored when `exact` is `true`
            #   * when `false`: it does not do anything additional
            #   * when `Regex`: it removes all characters that match the expression.
            #   * when `String`: each character listed is removed.
            #   * when `Array`: reduces `str` processing `ignore` in order.
            #   * when `true` (or otherwise): it removes all non a-zA-Z characters but blank spaces.
            def simplify_string(str, ignore: false)
              str = str.to_s.strip.downcase.gsub(/\s+/, ' ')
              return str unless ignore
              sub = non_letters_regex
              case ignore
              when Regexp; sub = ignore
              when String; sub = /[#{ignore}]+/
              when Array
                return ignore.reduce(str) do |out, sub|
                  simplify_string(out, ignore: sub)
                end
              end
              str.gsub(sub, '').gsub(/\s+/, ' ').strip
            end

            # Offers multiple simplification methods to compare two strings
            # @note only one of the values can be a Regexp
            # @param value1 [String, Regexp, Nil]
            # @param value2 [String, Regexp, Nil]
            # @param exact [Boolean]
            #   * when `true`: requiring the values to be exactly the same
            #   * otherwise (`false`): compares in downcase, with no extra spaces
            # @param mild [Boolean] only a-z comparison
            # @param ignore [see @simplify_string]
            def same_string?(value1, value2, exact: false, mild: false, ignore: false)
              return true  if value1.to_s.strip.empty? && value2.to_s.strip.empty?
              return false if value1.to_s.strip.empty? || value2.to_s.strip.empty?
              val1, val2 = value1, value2
              unless exact
                if val1.is_a?(String)
                  val1 = simplify_string(val1, ignore: ignore) if ignore
                  val1 = simplify_string(val1, ignore: non_letters_regex) if mild
                end
                if val2.is_a?(String)
                  val2 = simplify_string(val2, ignore: ignore) if ignore
                  val2 = simplify_string(val2, ignore: non_letters_regex) if mild
                end
              end
              case
              when val1.is_a?(String) && val2.is_a?(String)
                val1 == val2
              when val1.is_a?(Regexp) && val2.is_a?(String)
                val2 =~ val1
              when val1.is_a?(String) && val2.is_a?(Regexp)
                val1 =~ val2
              else
                #val1 == val2
                raise "Expected at least one String, and either a String or Regex. Given: (1: #{val1.class}) and (2: #{val2.class})"
              end
            end

            def titleize(str)
              return nil unless str
              return str if str.strip.empty?
              str.split(/\s+/).map do |part|
                part[0] = part[0].upcase
                part[1..-1] = part[1..-1].downcase
                part
              end.join(" ")
            end

            def normalize_string(str)
              return nil unless str
              str.gsub(/[^[:print:]]/, '')
              .gsub(/[[:space:]]+/, ' ')
              .gsub(/[[:space:]]$/, '')
              .gsub(/[-\u2011\u2012\u2013]/, '-').yield_self do |str|
                str = yield(str) if block_given?
                str
              end
            end

            def clean_question(str)
              return nil unless str
              normalize_string(str) do |str|
                str.gsub(/\r\n/, ' ').yield_self do |str|
                  str = yield(str) if block_given?
                  str
                end
              end
            end

            def object_reference(obj)
              return "No reference" unless obj
              "".tap do |ref|
                case obj
                when Ecoportal::API::V2::Page::Stage
                  ref << "Stage"
                when Ecoportal::API::V2::Pages::PageStage
                  ref << "Page (#{obj.id}) (#{object_reference(obj.current_stage)})"
                when Ecoportal::API::V2::Page
                  ref << "Page"
                when Ecoportal::API::V2::Page::Section
                  ref << "Section '#{obj.heading || "(unnamed)"}'"
                when Ecoportal::API::V2::Page::Component
                  ref << "Component '#{obj.label || "(unnamed of type '#{obj.type}')"}' in #{object_reference(obj.section)}"
                when Ecoportal::API::V2::Page::Force
                  ref << "Force '#{obj.name}'"
                when Ecoportal::API::V2::Page::Force::Binding
                  ref << "Binding '#{obj.name}' in #{object_reference(obj.force)}"
                end
                ref << " '#{obj.name}'" if obj.respond_to?(:name)
              end
            end

            def to_i(value)
              Float(value).to_i
            end

            # https://stackoverflow.com/a/5661695/4352306
            def is_number?(value)
              begin
                true if Float(value)
              rescue ArgumentError => e
                false
              end
            end
          end
        end
      end
    end
  end
end