class Gitlab::QA::Support::GitlabVersionInfo

def current_major
  @current_major ||= current_version.match(COMPONENT_PATTERN)[:major].to_i
end

def current_minor
  @current_minor ||= current_version.match(COMPONENT_PATTERN)[:minor].to_i
end

def current_patch
  @current_patch ||= current_version.match(COMPONENT_PATTERN)[:patch].to_i
end

def fallback_major
  previous_fallback_version(current_major - 1)
end

def fallback_minor
  return previous_fallback_version(current_major, current_minor - 1) unless current_minor.zero?
  previous_major
end

def fallback_patch
  return previous_fallback_version(current_major, current_minor, current_patch - 1) unless current_patch.zero?
  previous_minor
end

def initialize(current_version, edition)
  @current_version = current_version
  @edition = edition
  @logger = Runtime::Logger.logger
end

def latest_patch(version)
  versions.find { |ver| ver.to_s.match?(/^#{version}/) }
end

def previous_fallback_version(major_component, minor_component = 0, patch_component = 0)
  Gem::Version.new("#{major_component}.#{minor_component}.#{patch_component}")
end

def previous_major
  return fallback_major unless tags
  versions.find { |version| version.to_s.start_with?((current_major - 1).to_s) }
end

def previous_minor
  return fallback_minor unless tags
  return previous_major if current_minor.zero?
  versions.find { |version| version.to_s.match?(/^#{current_major}\.#{current_minor - 1}/) }
end

def previous_patch
  return fallback_patch unless tags
  return previous_minor if current_patch.zero?
  versions.find { |version| version.to_s.match?(/^#{current_major}\.#{current_minor}\.#{current_patch - 1}/) }
end

def previous_version(semver_component)
  case semver_component
  when "major"
    previous_major
  when "minor"
    previous_minor
  when "patch"
    previous_patch
  else
    raise("Unsupported semver component, must be major|minor|patch")
  end
end

def tags
  return @tags if defined?(@tags)
  logger.info("Fetching docker tags from 'gitlab/gitlab-#{edition}' registry")
  response = HttpRequest.make_http_request(
    url: "https://registry.hub.docker.com/v2/namespaces/gitlab/repositories/gitlab-#{edition}/tags?page_size=1000",
    fail_on_error: false
  )
  unless response.code == 200
    logger.error("  failed to fetch docker tags - code: #{response.code}, response: '#{response.body}'")
    return @tags = nil
  end
  @tags = JSON
    .parse(response.body, symbolize_names: true)
    .fetch(:results)
    .map { |tag| tag[:name] }
    .select { |tag| tag.match?(VERSION_PATTERN) }
end

def version(tag)
  tag.match(VERSION_PATTERN)[:version]
end

def versions
  @versions = tags
    .map { |tag| Gem::Version.new(tag.match(VERSION_PATTERN)[:version]) }
    .sort
    .reverse # reverse array so first match by .find always returns latest version
end