module SemanticRange

# File lib/semantic_range.rb, line 242
def self.clean(version, loose: false)
  s = parse(version.strip.gsub(/^[=v]+/, ''), loose: loose)
  return s ? s.version : nil
end

# File lib/semantic_range.rb, line 61
def self.cmp(a, op, b, loose: false)
  case op
  when '==='
    a = a.version if !a.is_a?(String)
    b = b.version if !b.is_a?(String)
    a == b
  when '!=='
    a = a.version if !a.is_a?(String)
    b = b.version if !b.is_a?(String)
    a != b
  when '', '=', '=='
    eq?(a, b, loose: loose)
  when '!='
    neq?(a, b, loose: loose)
  when '>'
    gt?(a, b, loose: loose)
  when '>='
    gte?(a, b, loose: loose)
  when '<'
    lt?(a, b, loose: loose)
  when '<='
    lte?(a, b, loose: loose)
  else
    raise 'Invalid operator: ' + op
  end
end

# File lib/semantic_range.rb, line 183
def self.compare(a, b, loose: false)
  Version.new(a, loose: loose).compare(b)
end

# File lib/semantic_range.rb, line 187
def self.compare_loose(a, b)
  compare(a, b, loose: true)
end

# File lib/semantic_range.rb, line 260
def self.diff(a, b)
  a = Version.new(a, loose: false) unless a.kind_of?(Version)
  b = Version.new(b, loose: false) unless b.kind_of?(Version)
  pre_diff = a.prerelease.to_s != b.prerelease.to_s
  pre = pre_diff ? 'pre' : ''
  return "#{pre}major" if a.major != b.major
  return "#{pre}minor" if a.minor != b.minor
  return "#{pre}patch" if a.patch != b.patch
  return "prerelease"  if pre_diff
end

# File lib/semantic_range.rb, line 211
def self.eq?(a, b, loose: false)
  compare(a, b, loose: loose) == 0
end

# File lib/semantic_range.rb, line 159
def self.filter(versions, range, loose: false, platform: nil)
  return [] if !valid_range(range, loose: loose, platform: platform)

  versions.filter { |v| SemanticRange.satisfies?(v, range, loose: loose, platform: platform) }
end

# File lib/semantic_range.rb, line 207
def self.gt?(a, b, loose: false)
  compare(a, b, loose: loose) > 0
end

# File lib/semantic_range.rb, line 219
def self.gte?(a, b, loose: false)
  compare(a, b, loose: loose) >= 0
end

# File lib/semantic_range.rb, line 57
def self.gtr?(version, range, loose: false, platform: nil)
  outside?(version, range, '>', loose: loose, platform: platform)
end

# File lib/semantic_range.rb, line 254
def self.increment!(version, release, identifier, loose: false)
  Version.new(version, loose: loose).increment!(release, identifier).version
rescue InvalidIncrement, InvalidVersion
  nil
end

# File lib/semantic_range.rb, line 203
def self.lt?(a, b, loose: false)
  compare(a, b, loose: loose) < 0
end

# File lib/semantic_range.rb, line 223
def self.lte?(a, b, loose: false)
  compare(a, b, loose: loose) <= 0
end

# File lib/semantic_range.rb, line 53
def self.ltr?(version, range, loose: false, platform: nil)
  outside?(version, range, '<', loose: loose, platform: platform)
end

# File lib/semantic_range.rb, line 165
def self.max_satisfying(versions, range, loose: false, platform: nil)
  versions.select { |version|
    satisfies?(version, range, loose: loose, platform: platform)
  }.sort { |a, b|
    rcompare(a, b, loose: loose)
  }[0] || nil
end

# File lib/semantic_range.rb, line 215
def self.neq?(a, b, loose: false)
  compare(a, b, loose: loose) != 0
end

# File lib/semantic_range.rb, line 88
def self.outside?(version, range, hilo, loose: false, platform: nil)
  version = Version.new(version, loose: loose)
  range = Range.new(range, loose: loose, platform: platform)

  return false if satisfies?(version, range, loose: loose, platform: platform)

  case hilo
  when '>'
    comp = '>'
    ecomp = '>='
  when '<'
    comp = '<'
    ecomp = '<='
  end

  range.set.each do |comparators|
    high = nil
    low = nil

    comparators.each do |comparator|
      if comparator.semver == ANY
        comparator = Comparator.new('>=0.0.0', loose)
      end

      high = high || comparator
      low = low || comparator

      case hilo
      when '>'
        if gt?(comparator.semver, high.semver, loose: loose)
          high = comparator
        elsif lt?(comparator.semver, low.semver, loose: loose)
          low = comparator
        end
      when '<'
        if lt?(comparator.semver, high.semver, loose: loose)
          high = comparator
        elsif gt?(comparator.semver, low.semver, loose: loose)
          low = comparator
        end
      end
    end

    return false if (high.operator == comp || high.operator == ecomp)

    case hilo
    when '>'
      if (low.operator.empty? || low.operator == comp) && lte?(version, low.semver, loose: loose)
        return false;
      elsif (low.operator == ecomp && lt?(version, low.semver, loose: loose))
        return false;
      end
    when '<'
      if (low.operator.empty? || low.operator == comp) && gte?(version, low.semver, loose: loose)
        return false;
      elsif low.operator == ecomp && gt?(version, low.semver, loose: loose)
        return false;
      end
    end
  end
  true
end

# File lib/semantic_range.rb, line 247
def self.parse(version, loose: false)
  return version if version.is_a?(Version)
  return nil unless valid?(version, loose: loose)

  Version.new(version.strip, loose: loose)
end

# File lib/semantic_range.rb, line 191
def self.rcompare(a, b, loose: false)
  compare(b, a, loose: true)
end

# File lib/semantic_range.rb, line 199
def self.rsort(list, loose: false)
  # TODO
end

# File lib/semantic_range.rb, line 151
def self.satisfies?(version, range, loose: false, platform: nil)
  if valid?(range, loose: loose) 
    return version == range
  end
  return false if !valid_range(range, loose: loose, platform: platform)
  Range.new(range, loose: loose, platform: platform).test(version)
end

# File lib/semantic_range.rb, line 195
def self.sort(list, loose: false)
  # TODO
end

# File lib/semantic_range.rb, line 271
def self.to_comparators(range, loose: false, platform: nil)
  Range.new(range, loose: loose, platform: platform).set.map do |comp|
    comp.map(&:to_s)
  end
end

# File lib/semantic_range.rb, line 237
def self.valid(version, loose: false)
  v = parse(version, loose: loose)
  return v ? v.version : nil
end

# File lib/semantic_range.rb, line 227
def self.valid?(version, loose: false)
  return false unless version.is_a?(String)

  stripped_version = version.strip
  return false if stripped_version.length > MAX_LENGTH

  rxp = loose ? LOOSE : FULL
  return rxp.match?(stripped_version)
end

# File lib/semantic_range.rb, line 173
def self.valid_range(range, loose: false, platform: nil)
  begin
    r = Range.new(range, loose: loose, platform: platform).range
    r = '*' if r.nil? || r.empty?
    r
  rescue
    nil
  end
end