class RuboCop::Cop::Sorbet::ValidSigil

def autocorrect(_node)
  lambda do |corrector|
    return unless require_sigil_on_all_files?
    return unless extract_sigil(processed_source).nil?
    token = processed_source.tokens.first
    corrector.insert_before(token.pos, "# typed: #{minimum_strictness || suggested_strictness}\n")
  end
end

def check_sigil_present(sigil)
  return true unless sigil.nil?
  token = processed_source.tokens.first
  if require_sigil_on_all_files?
    strictness = minimum_strictness || suggested_strictness
    add_offense(
      token,
      location: token.pos,
      message: 'No Sorbet sigil found in file. ' \
        "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this)."
    )
  end
  false
end

def check_strictness_level(sigil, strictness)
  return true unless minimum_strictness
  minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
  current_level = STRICTNESS_LEVELS.index(strictness)
  if current_level < minimum_level
    add_offense(
      sigil,
      location: sigil.pos,
      message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`."
    )
    return false
  end
  true
end

def check_strictness_not_empty(sigil, strictness)
  return true if strictness
  add_offense(
    sigil,
    location: sigil.pos,
    message: 'Sorbet sigil should not be empty.'
  )
  false
end

def check_strictness_valid(sigil, strictness)
  return true if STRICTNESS_LEVELS.include?(strictness)
  add_offense(
    sigil,
    location: sigil.pos,
    message: "Invalid Sorbet sigil `#{strictness}`."
  )
  false
end

def extract_sigil(processed_source)
  processed_source.tokens
    .take_while { |token| token.type == :tCOMMENT }
    .find { |token| SIGIL_REGEX.match?(token.text) }
end

def extract_strictness(sigil)
  sigil.text.match(SIGIL_REGEX)&.captures&.first
end

def investigate(processed_source)
  return if processed_source.tokens.empty?
  sigil = extract_sigil(processed_source)
  return unless check_sigil_present(sigil)
  strictness = extract_strictness(sigil)
  return unless check_strictness_not_empty(sigil, strictness)
  return unless check_strictness_valid(sigil, strictness)
  return unless check_strictness_level(sigil, strictness)
end

def minimum_strictness
  cop_config['MinimumStrictness']
end

def require_sigil_on_all_files?
  !!cop_config['RequireSigilOnAllFiles']
end

def suggested_strictness
  cop_config['SuggestedStrictness'] || 'false'
end