module PIM::Utils

# File pim.rb, line 1501
def add_to_collection collection, key, value = nil

  return if key.nil?

  if collection.respond_to?(:<<)
    if value.nil?
      collection << key
    else
      collection << [key, value]
    end
  elsif collection.respond_to?(:[]=)
    collection[key] = value
  end

end

# File pim.rb, line 1455
def add_to_hashed_array hashed_array, key, value
  hashed_array[key] ||= []
  hashed_array[key] << value unless hashed_array[key].include?(value)
end

# File pim.rb, line 927
def array_from_json json, location
  array = case
    when is_empty?(json)
      []
    when json.is_a?(String)
      JSON.parse(json)
    when is_array?(json)
      json
    else
      raise "Value #{value_msg(json)}#{location} cannot be transformed into an array"
  end
end

# File pim.rb, line 831
def as_json value
  as_json = case
    when value.nil?
      nil
    when value.respond_to?(:as_json)
      value.as_json
    when is_array?(value)
      array = []
      value.each { |v| array << as_json(v) }
      array
    when is_hash?(value)
      hash = {}
      value.each { |k,v| hash[k] = as_json(v) }
      hash
    when is_range?(value)
      value.to_s
    when is_set?(value)
      array = []
      value.each { |v| array << as_json(v) }
      array
    else
      value
  end
end

# File pim.rb, line 1584
def calculate_checksum value
    checksum = 0
    multiply_3 = true
    value.chop.reverse.each_char do |c|
      checksum += c.to_i * (if multiply_3 then 3 else 1 end)
      multiply_3 = !multiply_3
    end
    checksum = (10 - (checksum % 10)).to_s[-1,1]
end

# File pim.rb, line 856
def camelize value
  case
    when is_array?(value)
      value.map { |v| camelize(v) }
    when is_hash?(value)
      Hash[value.map { |k, v| [camelize(k).to_sym, v] }]
    when is_set?(value)
      value.map { |v| camelize(v) }
    else
      value.to_s.split('_').inject([]) { |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
  end
end

# File pim.rb, line 1594
def check_class value, check_class

  return true if value.nil? or value.is_a?(PIM::ErrorValue)

  # Check if value needs to be normalized
  if not value.is_a?(check_class)
    begin
      if check_class < Numeric
        value = to_numeric(value, check_class) || value
      elsif check_class <= DateTime
        value = normalize_value(value) { |v| parse_datetime(v) }
      elsif check_class <= Date
        value = normalize_value(value) { |v| Date.parse(v.to_s) }
      end
    rescue
    end
  end

  return true if value.is_a?(check_class)
  return false

end

# File pim.rb, line 1578
def check_task_retry_exception exception, &block
  if PIM::Services.is_services_available?
    PIM::Services::ProcessTaskService.check_task_retry_exception(exception, &block)
  end
end

# File pim.rb, line 1556
def cleanup_filename filename
  filename.tr INVALID_FILENAME_CHARACTERS, INVALID_FILENAME_CHARACTER_REPLACEMENT
end

# File pim.rb, line 1223
def compact_args *args
  args = args.compact
  if args.size == 1
    arg = args[0]
    return arg.compact if is_array?(arg)
    return arg if is_hash?(arg)
  end
  args
end

# File pim.rb, line 878
def constantize camel_cased_word

  names = camel_cased_word.split('::')

  # Trigger a built-in NameError exception including the ill-formed constant in the message.
  if names.empty?
    return nil if camel_cased_word.nil? or camel_cased_word.empty?
    Object.const_get(camel_cased_word) if names.empty?
  end

  # Remove the first blank element in case of '::ClassName' notation.
  names.shift if names.size > 1 && names.first.empty?

  names.inject(Object) do |constant, name|
    if constant == Object
      constant.const_get(name)
    else
      candidate = constant.const_get(name)
      next candidate if constant.const_defined?(name, false)
      next candidate unless Object.const_defined?(name)

      # Go down the ancestors to check if it is owned directly. The check
      # stops when we reach Object or the end of ancestors tree.
      constant = constant.ancestors.inject do |const, ancestor|
        break const if ancestor == Object
        break ancestor if ancestor.const_defined?(name, false)
        const
      end

      # owner is in Object, so raise
      constant.const_get(name, false)
    end
  end
end

# File pim.rb, line 1560
def create_trafo_content_stream items, content_type, params = {}
  PIM::Services::CommunicationPlanService.create_trafo_content_stream(items, content_type, params)
end

# File pim.rb, line 1362
def date_after? date, min_date
  return false if date.nil?
  return true if min_date.nil?
  return date > min_date
end

# File pim.rb, line 1368
def date_before? date, max_date
  return false if date.nil?
  return true if max_date.nil?
  return date < max_date
end

# File pim.rb, line 1358
def date_between? date, min_date, max_date
  return date_after?(date, min_date) && date_before?(date, max_date)
end

# File pim.rb, line 913
def deconstantize path
  path = path.to_s
  path[0, path.rindex('::') || 0]
end

# File pim.rb, line 953
def deep_merge_if_absent value1, value2
  if is_hash?(value1) and is_hash?(value2)
    value2.each do |k2, v2|
      if is_hash?(v2) and !value1.has_key?(k2)
        value1[k2] = {} # force deep copy for hashes
      end
    end
    return value1.merge(value2) { |k, v1, v2| deep_merge_if_absent(v1, v2) }
  end

  return value1 unless value1.nil?
  return value2
end

# File pim.rb, line 918
def demodulize path
  path = path.to_s
  if i = path.rindex("::")
    path[(i + 2)..-1]
  else
    path
  end
end

# File pim.rb, line 1460
def dup_value value
  case
    when value.nil?
      nil
    when value.is_a?(ErrorValue)
      value.error_value.to_s
    when value.is_a?(Struct)
      value.dup
    when value.is_a?(MultiDimensional)
      value.dup
    when is_array?(value)
      array = []
      value.each { |v| array << dup_value(v) }
      array
    when is_hash?(value)
      hash = {}
      value.each { |k,v| hash[k] = dup_value(v) }
      hash
    when is_range?(value)
      value.dup
    when is_set?(value)
      array = []
      value.each { |v| array << dup_value(v) }
      array
    when is_date?(value)
      value.dup
    else
      value
  end
end

# File pim.rb, line 1517
def escape_html s
  s.gsub!(/</, '&lt;')
  s.gsub!(/>/, '&gt;')
  s.gsub!(/\n/, '<br>')
  s.gsub!(/\t/, '    ')
  s
end

# File pim.rb, line 1163
def execute_on_parent object, &block

  names = object.to_s.split("::")

  if names.length == 1
    parent = Object
    const = object.to_s.to_sym
  else
    parent = nil
    const = nil
    names.each do |name|
      parent = (parent and const) ? parent.const_get(const) : Object
      const = name.to_sym
    end
  end

  parent.module_exec(const, &block)

end

# File pim.rb, line 1278
def get_hash_key hash, key, default_value = nil
  return default_value if is_empty?(hash)
  key_sym = to_sym(key)
  return key_sym if hash.key?(key_sym)
  key_s = key.to_s
  return key_s if hash.key?(key_s)
  return default_value
end

# File pim.rb, line 1268
def get_hash_value hash, key, default_value = nil
  key_sym = to_sym(key)
  return hash[key_sym] if hash.key?(key_sym)
  key_s = key.to_s
  return hash[key_s] if hash.key?(key_s)
  value = hash[key_sym] || hash[key_s]
  value = hash[key_sym] = default_value if value.nil? and not default_value.nil?
  value
end

# File pim.rb, line 1263
def get_method object, name
  method_name = to_sym(name)
  return object.method(method_name) if is_symbol?(method_name) and object.respond_to?(method_name)
end

# File pim.rb, line 1258
def get_method_value object, key
  method = get_method(object, key)
  value = method.call() unless method.nil? or method.arity > 0
end

# File pim.rb, line 1296
def get_opt opts, option, default = nil
  return default if is_empty?(opts)
  if opts.include?(option)
    return opts[option]
  elsif opts.include?(option.to_s)
    return opts[option.to_s]
  else
    return default
  end
end

# File pim.rb, line 1525
def get_service_name service
  return nil if is_empty?(service)
  return service.service_name if PIM.has_module?(service)
  return service.to_s
end

# File pim.rb, line 1238
def get_value object, *keys
  return nil if object.nil?
  value = nil
  keys.each do |key|
    if not is_struct?(object) and is_hash?(object)
      value = get_hash_value(object, key)
      if value.nil? and is_meta_attribute?(key) and is_java_item?(object)
        method_name = snakeize(key.to_s.delete_suffix('__'))
        value = get_method_value(object, method_name)
      end
    elsif is_array?(object) and key.is_a?(Integer)
      value = object[key]
    else
      value = get_method_value(object, key)
    end
    break unless value.nil?
  end
  return value
end

# File pim.rb, line 1287
def has_hash_key? hash, key
  return false if is_empty?(hash)
  key_sym = to_sym(key)
  return true if hash.key?(key_sym)
  key_s = key.to_s
  return true if hash.key?(key_s)
  return false
end

# File pim.rb, line 819
def has_java?
  return Module.const_defined?('Java')
end

# File pim.rb, line 1307
def has_opt? opts, option, compare_value, default = nil
  opt_value = get_opt(opts, option, default)
  return true if opt_value == compare_value or opt_value.to_s == compare_value.to_s
  return false
end

# File pim.rb, line 940
def hash_from_json json, location
  hash = case
    when is_empty?(json)
      {}
    when json.is_a?(String)
      JSON.parse(json)
    when is_hash?(json)
      json
    else
      raise "Value #{value_msg(json)}#{location} cannot be transformed into a hash"
  end
end

# File pim.rb, line 1153
def hash_value_for_key hash, *keys
  keys.each do |key|
    return hash[key] if hash.has_key?(key)
    if is_string?(key)
      key = key.to_sym
      return hash[] if hash.has_key?(key)
    end
  end
end

# File pim.rb, line 1531
def includes_value? value, values
  return false if is_empty?(values)
  return true if values.include?(value)
  if value.respond_to?(:to_sym)
    return true if values.include?(value.to_sym)
  end
  if value.respond_to?(:to_s)
    return true if values.include?(value.to_s)
  end
  return false
end

# File pim.rb, line 967
def is_array? value
  return value.respond_to?(:to_ary)
end

# File pim.rb, line 1028
def is_blank? value
  return true if value.nil?
  return value.empty? if value.respond_to?(:empty?)
  return value.to_s.nil? || value.to_s.empty?
end

# File pim.rb, line 971
def is_collection? value
  return is_array?(value) || is_set?(value)
end

# File pim.rb, line 1011
def is_date? value
  return value.respond_to?(:to_date)
end

# File pim.rb, line 1015
def is_empty? value
  return true if is_error?(value)
  self.is_blank? value
end

# File pim.rb, line 1040
def is_equal? this, that
  return true if this.__id__ == that.__id__
  return true if is_empty?(this) and is_empty?(that)
  return false if is_empty?(this) != is_empty?(that)
  return this == that
end

# File pim.rb, line 1020
def is_error? value
  return value.is_a?(PIM::ErrorValue)
end

# File pim.rb, line 975
def is_hash? value
  return value.respond_to?(:to_hash)
end

# File pim.rb, line 827
def is_java_item? object
  has_java? and defined?(com.lansa.lax.pim::Item) == 'constant' and object.is_a?(com.lansa.lax.pim::Item)
end

# File pim.rb, line 823
def is_java_object? object
  has_java? and defined?(java.lang::Object) == 'constant' and object.is_a?(java.lang::Object)
end

# File pim.rb, line 1034
def is_meta_attribute? attribute
  return is_meta_attribute?(attribute.name) if attribute.is_a?(PIM::Attribute)
  return false if !attribute
  attribute.to_s.end_with?('__')
end

# File pim.rb, line 1095
def is_non_javaify_class? value
  value_class = value.class
  if has_java?
    return true if value_class <= java.lang.Object
  end
  NON_JAVAIFY_CLASSES.each do |non_javaify_class|
    return true if value_class <= non_javaify_class
  end
  return false
end

# File pim.rb, line 1024
def is_not_empty? value
  return !is_empty?(value)
end

# File pim.rb, line 1313
def is_opt? opts, option, default = false
  return has_opt?(opts, option, true, default)
end

# File pim.rb, line 979
def is_proc? value
  return value.class <= Proc
end

# File pim.rb, line 983
def is_range? value
  return value.class <= Range
end

# File pim.rb, line 987
def is_regexp? value
  return value.is_a?(Regexp)
end

# File pim.rb, line 991
def is_set? value
  return value.respond_to?(:to_set)
end

# File pim.rb, line 995
def is_string? value
  return value.respond_to?(:to_str)
end

# File pim.rb, line 999
def is_struct? value
  return value.class <= Struct
end

# File pim.rb, line 1003
def is_symbol? value
  return value.class <= Symbol
end

# File pim.rb, line 1007
def is_symbol_or_string? value
  return is_symbol?(value) || is_string?(value)
end

# File pim.rb, line 1119
def javaify_array array
  return nil if array.nil?
  return array if not is_array?(array)
  if has_java? and array.class <= java.lang.Object
    array.each_with_index { |v, i| array[i] = javaify_value(v) }
    new_array = array
  else
    new_array = java.util.LinkedList.new
    array.each { |v| new_array << javaify_value(v) }
  end
  new_array
end

# File pim.rb, line 1133
def javaify_hash hash
  return nil if hash.nil?
  return hash if not is_hash?(hash)
  if has_java? and hash.class <= java.lang.Object
    hash.each_pair { |k,v| hash[k] = javaify_value(v) }
    new_hash = hash
  else
    new_hash = java.util.LinkedHashMap.new
    hash.each_pair { |k,v| new_hash.put(javaify_value(k), javaify_value(v)) }
  end
  new_hash
end

# File pim.rb, line 1106
def javaify_value value
  return case
    when value.nil? then nil
    when value.respond_to?(:as_json) then javaify_value(value.as_json)
    when is_array?(value) then javaify_array(value)
    when is_hash?(value) then javaify_hash(value)
    when is_non_javaify_class?(value) then value
    else value.to_s
  end
end

# File pim.rb, line 1047
def length value
  return 0 if !value
  return value.length if value.respond_to?(:length)
  value.to_s.length
end

# File pim.rb, line 1326
def parse_datetime value

  return nil if is_empty?(value)

  if value.is_a?(Time) or value.is_a?(Date)
    date = value
  elsif value.is_a?(Numeric)

    # Milliseconds must be specified as fraction
    value = value / 1000
    date = Time.at(value).to_datetime

  else

    #  DateTime is normally specified as 'Unix Time' value
    int_value = value.to_s.to_i
    if int_value.to_s == value.to_s
      return parse_datetime(int_value)
    end

    # Try to parse the string as good as possible
    date = DateTime.parse(value.to_s)

  end

  # Correct time zone offset
  local_zone = Time.now.zone
  date = date.new_offset(local_zone)
  date

end

# File pim.rb, line 1147
def remove_const_on_parent object
  execute_on_parent(object) do |const|
    remove_const(const) if const_defined?(const)
  end
end

# File pim.rb, line 1543
def safe_reference_replace string, params, missing_replacement = "?"
  begin
    string % params
  rescue KeyError => e
    # Try to extract the missing key
    missing_key = e.message.gsub(/.*\{(.*)\}.*/, '\1')
    if not is_empty?(missing_key) and not params.include?(missing_key.to_sym)
      params[missing_key.to_sym] = missing_replacement
      retry
    end
  end
end

# File pim.rb, line 869
def snakeize name
  name.to_s.strip.
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z][A-Z\d]*)/,'\1_\2').
    tr("-", "_").
    gsub(/_+/, '_').
    downcase
end

# File pim.rb, line 1065
def stringified_array array
  return nil if is_empty?(array)
  return array.to_a if not is_array?(array) and array.respond_to?(:to_a)
  return [array] if not is_array?(array)
  array.map{ |v| stringified_value(v) }
end

# File pim.rb, line 1079
def stringified_compact_unique_array *array
  return array if array.empty?
  return array.compact.uniq.map { |v| v.to_s }
end

# File pim.rb, line 1072
def stringified_hash hash
  return nil if is_empty?(hash)
  return hash.to_h if not is_hash?(hash) and hash.respond_to?(:to_h)
  return hash if not is_hash?(hash)
  Hash[hash.map{ |k,v| [stringified_value(k), stringified_value(v)] }]
end

# File pim.rb, line 1053
def stringified_value value
  return case
    when is_empty?(value) then nil
    when is_array?(value) then stringified_array(value)
    when is_hash?(value) then stringified_hash(value)
    when value.is_a?(Numeric) then value
    when value.is_a?(String) then value
    else value.to_s
  end
end

# File pim.rb, line 1183
def symbolized_array array
  return nil if !array
  new_array = []
  array.each { |value| new_array << value.to_s.strip.to_sym }
  new_array
end

# File pim.rb, line 1190
def symbolized_hash hash
  new_hash = {}
  return new_hash if !hash
  hash.each { |key, value| new_hash[key.to_s.strip.to_sym] = value }
  new_hash
end

# File pim.rb, line 1211
def symbolized_snakeized_hash hash
  new_hash = {}
  return new_hash if !hash
  hash.each { |key, value| new_hash[snakeize(key).to_sym] = value }
  new_hash
end

# File pim.rb, line 1747
def timed group: nil, key: nil, results: nil, result_handler: nil, message: nil, filterable: false, &block

  # Either explicitly define 'results' or 'result_handler',
  # or use 'group' to determine the value from a global variable
  unless group.nil? or ($timed_results.nil? and $timed_result_handlers.nil?)
    results ||= PIM.get_value($timed_results, group)
    result_handler ||= PIM.get_value($timed_result_handlers, group)
  end

  return block.call if key.nil? or (results.nil? and result_handler.nil?)

  require 'benchmark'

  return_value = nil
  exception = nil

  duration = Benchmark.realtime do
    begin
      return_value = block.call
    rescue => e
      exception = e
    end
  end

  message = message.call if is_proc?(message)
  message = message % { key: key } unless message.nil?
  result = TimedResult.new key: key, duration: duration, message: message, filterable: filterable

  results << PIM.stringified_hash(result.to_h) unless results.nil? # Store as 'stringified' Hash
  result_handler.call(result) unless result_handler.nil?

  raise exception unless exception.nil?
  return return_value

end

# File pim.rb, line 1317
def to_date value
  begin
    parse_datetime value
  rescue Exception => e
    log_error("Could not parse date from value '#{value}'", e)
    return nil
  end
end

# File pim.rb, line 1374
def to_gtin value
  if (value && value.respond_to?(:rjust))
    return value.rjust(14, '0')
  else
    return value
  end
end

# File pim.rb, line 1382
def to_instance_variable_name value
  to_sym("@#{value}")
end

# File pim.rb, line 1564
def to_java_exception exception

  return nil unless has_java?

  # Convert to java throwable, if necessary and possible
  exception = exception.to_java if exception.respond_to?(:to_java)
  exception = exception.to_throwable if exception.respond_to?(:to_throwable)

  # Ensure, exception is a Java exception
  return exception if exception.class <= java.lang.Throwable

  return nil
end

# File pim.rb, line 1233
def to_key_value_list hash
  return hash unless is_hash?(hash)
  hash.map { |k,v| { :key => k, :value => v } }
end

# File pim.rb, line 1397
def to_numeric value, default_numeric_class = Float

  return nil if is_empty?(value)

  # Handle Physical attribute value
  value = value.values.first if value.is_a?(Hash)

  # Try to convert to Float, unless value is already numeric
  if not value.is_a?(Numeric) and default_numeric_class < Numeric
    begin
      value = Object.send(default_numeric_class.to_s, value)
    rescue
      value = nil
    end
  end

  value

end

# File pim.rb, line 1391
def to_string object
  return object if object.is_a?(String)
  return '' if object.nil?
  object.to_s || ''
end

# File pim.rb, line 1386
def to_sym object
  return object if object.is_a?(Class) or !object.respond_to?(:to_sym)
  object.to_sym
end

# File pim.rb, line 1204
def unsymbolized_camelized_hash hash
  new_hash = {}
  return new_hash if !hash
  hash.each { |key, value| new_hash[camelize(key)] = value }
  new_hash
end

# File pim.rb, line 1197
def unsymbolized_hash hash
  new_hash = {}
  return new_hash if !hash
  hash.each { |key, value| new_hash[key.to_s] = value }
  new_hash
end

# File pim.rb, line 1417
def value_msg value

  # Add the class name, unless it is String or Symbol
  class_msg = (not [String, Symbol].include?(value.class)) ? "of class #{value.class} " : ""

  value_msg = case

    when value.nil?

      # Indicate that value is 'null'
      "<NULL> "

    when (value == true or value == false or value.is_a?(Numeric))

      # Show value as-is
      "#{value} "

    when (is_array?(value) or is_hash?(value) or value.is_a?(Struct))

      # Only show class
      "#{class_msg}"

    when to_string(value).length > 20

      # Show only up to 20 characters
      "'#{to_string(value).slice(0..14)}(...)' #{class_msg}"

    else

      # Show quoted value
      "'#{value}' #{class_msg}"

  end

  value_msg

end