module VersionUtils

# File lib/version_compare.rb, line 4
def self.compare(v1, v2)

  v1 = self.parse(v1)
  v2 = self.parse(v2)

  compare_major = self.compare_segment(v1[:major], v2[:major])
  if compare_major != 0
    return compare_major
  end

  compare_minor = self.compare_segment(v1[:minor], v2[:minor])
  if compare_minor != 0
    return compare_minor
  end

  compare_patch = self.compare_segment(v1[:patch], v2[:patch])
  if compare_patch != 0
    return compare_patch
  end

  return self.compare_pre_releae(v1[:pre_release], v2[:pre_release])

end

# File lib/version_compare.rb, line 50
def self.compare_pre_releae(pr1, pr2)

  if pr1 == nil && pr2 == nil
    return 0
  end

  if pr1 == nil && pr2 != nil
    return 1
  end

  if pr1 != nil && pr2 == nil
    return -1
  end

  pr1 = pr1.gsub(".", "")
  pr2 = pr2.gsub(".", "")

  if pr1 == pr2
    return 0
  end

  if pr1 > pr2
    return 1
  end

  if pr1 < pr2
    return -1
  end
end

# File lib/version_compare.rb, line 28
def self.compare_segment(s1, s2)
  if s1 == nil
    return -1
  end

  if s2 == nil
    return 1
  end

  if s1 == s2
    return 0
  end

  if s1 < s2
    return -1
  end

  if s1 > s2
    return 1
  end
end

# File lib/version_format.rb, line 2
def self.format(parts)
  version = []
  version = version + [parts[:major]]

  if parts[:minor] != nil
    version = version + [parts[:minor]]
  end

  if parts[:patch] != nil
    version = version + [parts[:patch]]
  end

  version = version.join(".")

  if parts[:pre_release] != nil
    version = version + "-" + parts[:pre_release]
  end

  if parts[:metadata] != nil
    version = version + "+" + parts[:metadata]
  end

  return version.force_encoding("utf-8")
end

# File lib/version_parse.rb, line 2
def self.parse(version)

  result = {}

  if version.split("+").length > 1
    metadata = version.split("+")[1]
    result[:metadata] = metadata
    version = version.split("+")[0]
  end

  if version.split("-").length > 1
    part_post_segments = version.split("-")[1]
    pre_release = part_post_segments.split("+")[0]
    result[:pre_release] = pre_release
    version = version.split("-")[0]

  end

  segments = version.split(".")

  result[:major] = Integer(segments[0])

  if segments.length > 1
    result[:minor] = Integer(segments[1])
  else
    result[:minor] = nil
  end

  if segments.length > 2
    result[:patch] = Integer(segments[2])
  else
    result[:patch] = nil
  end

  return result
end

# File lib/version_manipulation.rb, line 58
def self.update_metadata(version, update_build_version)
  if update_build_version
    begin
      build_version = Integer(version[:metadata])
      version[:metadata] = (build_version + 1).to_s
    rescue
      version[:metadata] = nil
    end
  else
    version[:metadata] = nil
  end
  return version
end

# File lib/version_manipulation.rb, line 46
def self.update_patch(version)
  if version[:patch] != nil
    version[:patch] = 0
  end
  return version
end

# File lib/version_manipulation.rb, line 53
def self.update_pre_release(version)
  version[:pre_release] = nil
  return version
end

# File lib/version_manipulation.rb, line 2
def self.upgrade_major(
    version,
    update_build_version: false)

  version = self.parse(version)

  version[:major] += 1

  if version[:minor] != nil
    version[:minor] = 0
  end

  version = self.update_patch(version)
  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)

  return self.format(version)
end

# File lib/version_manipulation.rb, line 21
def self.upgrade_minor(
    version,
    update_build_version: false)
  version = self.parse(version)

  version[:minor] += 1

  version = self.update_patch(version)
  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)
  return self.format(version)
end

# File lib/version_manipulation.rb, line 34
def self.upgrade_patch(
    version,
    update_build_version: false)
  version = self.parse(version)

  version[:patch] += 1

  version = self.update_pre_release(version)
  version = self.update_metadata(version, update_build_version)
  return self.format(version)
end