class CreateGithubRelease::Project

def backtick_debug?
  verbose?
end

def changelog_path
  @changelog_path ||= options.changelog_path || 'CHANGELOG.md'
end

def changes
  @changes ||= begin
    tip = "'HEAD'"
    base = first_release? ? '' : "'^#{last_release_tag}' "
    command = "git log #{tip} #{base}--oneline --format='format:%h\t%s'"
    git_log = `#{command}`
    raise "Could not determine changes since #{last_release_tag}" unless $CHILD_STATUS.success?
    git_log.split("\n").map { |l| ::CreateGithubRelease::Change.new(*l.split("\t")) }
  end
end

def current_version
  output = `gem-version-boss current`
  raise 'Could not determine current version using gem-version-boss' unless $CHILD_STATUS.success?
  output.lines.last.chomp
end

def default_branch
  @default_branch ||= options.default_branch || begin
    output = `git remote show '#{remote}'`
    raise "Could not determine default branch for remote '#{remote}'" unless $CHILD_STATUS.success?
    output.match(/HEAD branch: (.*?)$/)[1]
  end
end

def first_commit
  @first_commit ||= begin
    command = "git log 'HEAD' --oneline --format='format:%h'"
    git_log = `#{command}`
    raise "Could not list changes from first commit up to #{last_release_tag}" unless $CHILD_STATUS.success?
    git_log.split("\n").last.chomp
  end
end

def first_release
  @first_release ||= release_type == 'first'
end

def initialize(options)
  @options = options
  yield self if block_given?
  setup_first_release if release_type == 'first'
end

def last_release_changelog
  @last_release_changelog ||= begin
    File.read(changelog_path)
  rescue Errno::ENOENT
    ''
  rescue StandardError
    raise 'Could not read the changelog file'
  end
end

def last_release_tag
  @last_release_tag ||= (first_release? ? '' : "v#{last_release_version}")
end

def last_release_version
  @last_release_version ||= options.last_release_version || current_version
end

def list_of_changes
  return '* No changes' if changes.empty?
  changes.map do |change|
    "* #{change.sha} #{change.subject}"
  end.join("\n")
end

def next_release_changelog
  @next_release_changelog ||=
    CreateGithubRelease::Changelog.new(last_release_changelog, next_release_description).to_s
end

def next_release_date
  @next_release_date ||=
    if tag_exist?(next_release_tag)
      date = `git show --format=format:%aI --quiet "#{next_release_tag}"`
      raise "Could not determine date for tag '#{next_release_tag}'" unless $CHILD_STATUS.success?
      Date.parse(date.chomp)
    else
      Date.today
    end
end

def next_release_description
  @next_release_description ||= begin
    header = first_release? ? 'Changes:' : "Changes since #{last_release_tag}:"
    <<~DESCRIPTION
      ## #{next_release_tag} (#{next_release_date.strftime('%Y-%m-%d')})
      [Full Changelog](#{release_log_url})
      #{header}
      #{list_of_changes}
    DESCRIPTION
  end
end

def next_release_tag
  @next_release_tag ||= "v#{next_release_version}"
end

def next_release_version
  @next_release_version ||= options.next_release_version || next_version
end

def next_version
  output = `#{next_version_cmd}`
  raise 'Could not determine next version using gem-version-boss' unless $CHILD_STATUS.success?
  output.lines.last.chomp
end

def next_version_cmd
  cmd = "gem-version-boss next-#{release_type}"
  cmd << ' --pre' if pre
  cmd << " --pre-type=#{pre_type}" if pre_type
  cmd << ' --dry-run'
end

def pre
  @pre ||= options.pre
end

def pre_type
  @pre_type ||= options.pre_type
end

def quiet
  @quiet ||= options.quiet || false
end

def release_branch
  @release_branch ||= options.release_branch || "release-#{next_release_tag}"
end

def release_log_url
  @release_log_url ||= begin
    from = first_release? ? first_commit : last_release_tag
    to = next_release_tag
    URI.parse("#{remote_url}/compare/#{from}..#{to}")
  end
end

def release_pr_label
  @release_pr_label ||= options.release_pr_label || nil
end

def release_pr_number
  @release_pr_number ||= begin
    pr_number = `gh pr list --search "head:#{release_branch}" --json number --jq ".[].number"`.chomp
    pr_number.empty? ? nil : pr_number
  end
end

def release_pr_url
  @release_pr_url ||= release_pr_number.nil? ? nil : URI.parse("#{remote_url}/pull/#{release_pr_number}")
end

def release_type
  @release_type ||= options.release_type || raise(ArgumentError, 'release_type is required')
end

def release_url
  @release_url ||= URI.parse("#{remote_url}/releases/tag/#{next_release_tag}")
end

def remote
  @remote ||= options.remote || 'origin'
end

def remote_base_url
  @remote_base_url ||= URI.parse(remote_url.to_s[0..-remote_url.path.length])
end

def remote_repository
  @remote_repository ||= remote_url.path.sub(%r{^/}, '').sub(/\.git$/, '')
end

def remote_url
  @remote_url ||= begin
    remote_url_string = `git remote get-url '#{remote}'`
    raise "Could not determine remote url for remote '#{remote}'" unless $CHILD_STATUS.success?
    remote_url_string = remote_url_string.chomp
    remote_url_string = remote_url_string[0..-5] if remote_url_string.end_with?('.git')
    URI.parse(remote_url_string)
  end
end

def setup_first_release
  self.next_release_version = @next_release_version || current_version
  self.last_release_version = ''
  self.last_release_tag = ''
end

def tag_exist?(tag)
  tags = `git tag --list "#{tag}"`.chomp
  raise 'Could not list tags' unless $CHILD_STATUS.success?
  !tags.empty?
end

def to_s
  <<~OUTPUT
    first_release: #{first_release}
    default_branch: #{default_branch}
    next_release_tag: #{next_release_tag}
    next_release_date: #{next_release_date}
    next_release_version: #{next_release_version}
    last_release_tag: #{last_release_tag}
    last_release_version: #{last_release_version}
    release_branch: #{release_branch}
    release_log_url: #{release_log_url}
    release_type: #{release_type}
    release_url: #{release_url}
    remote: #{remote}
    remote_base_url: #{remote_base_url}
    remote_repository: #{remote_repository}
    remote_url: #{remote_url}
    release_pr_number: #{release_pr_number}
    release_pr_url: #{release_pr_url}
    changelog_path: #{changelog_path}
    verbose?: #{verbose?}
    quiet?: #{quiet?}
  OUTPUT
end

def verbose
  @verbose ||= options.verbose || false
end