base.rb

# frozen_string_literal: true

module Ecosystem
  class Base
    attr_accessor :registry
    attr_accessor :registry_url

    def initialize(registry)
      @registry = registry
      @registry_url = registry.url
    end

    def sync_in_batches?
      false
    end

    def sync_missing_packages_incrementally?
      false
    end

    def sync_maintainers_inline?
      false
    end

    def has_dependent_repos?
      true
    end

    def self.list
      @ecosystems ||= begin
        Dir[Rails.root.join("app", "models", "ecosystem", "*.rb")].sort.each do |file|
          require file unless file.match(/base\.rb$/)
        end
        Ecosystem.constants
          .reject { |ecosystem| ecosystem == :Base }
          .map { |sym| "Ecosystem::#{sym}".constantize }
          .sort_by(&:name)
      end
    end

    def self.format_name(ecosystem)
      return nil if ecosystem.nil?

      find(ecosystem).to_s.demodulize
    end

    def self.find(ecosystem)
      list.find { |p| p.lowercase_name == ecosystem.downcase }
    end

    def self.formatted_name
      to_s.demodulize
    end

    def self.lowercase_name
      formatted_name.downcase
    end

    def registry_url(_package, _version = nil)
      nil
    end

    def download_url(_package, _version = nil)
      nil
    end

    def documentation_url(_package, _version = nil)
      nil
    end

    def install_command(_package, _version = nil)
      nil
    end

    def maintainer_url(_maintainer)
      nil
    end

    def check_status_url(package)
      registry_url(package)
    end

    def docker_usage_path(package)
      "#{package.ecosystem}/#{package.name}"
    end

    def check_status(package)
      url = check_status_url(package)
      return nil if url.blank?

      begin
        URI.parse(url)
      rescue URI::InvalidURIError => e
        Rails.logger.warn("Invalid URI for package #{package.id} (#{package.name}): #{url} - #{e.message}")
        return false
      end

      connection = Faraday.new(url) do |faraday|
        faraday.use Faraday::FollowRedirects::Middleware
        faraday.request :instrumentation
        faraday.adapter Faraday.default_adapter
        faraday.options.timeout = 10
        faraday.options.open_timeout = 5
      end

      response = connection.head(url)
      return "removed" if [400, 404, 410].include?(response.status)
      return nil if response.success?

      false
    rescue => e
      Rails.logger.warn("Error checking status for package #{package.id} (#{package.name}): #{e.message}")
      false
    end

    def ecosystem_name(ecosystem)
      find(ecosystem).try(:formatted_name) || ecosystem
    end

    def dependencies_metadata(_name, _version, _package)
      []
    end

    def fetch_package_metadata(name, version: nil)
      cache_key = [name, version]
      return @last_fetched_metadata if @last_fetched_key == cache_key

      metadata = if version
                   fetch_package_metadata_for_version(name, version)
                 else
                   fetch_package_metadata_uncached(name)
                 end
      @last_fetched_key = cache_key
      @last_fetched_metadata = metadata
    end

    def fetch_package_metadata_for_version(name, _version)
      fetch_package_metadata_uncached(name)
    end

    def package_metadata(name, version: nil)
      map_package_metadata(fetch_package_metadata(name, version: version))
    end

    def map_dependencies(deps, kind, optional = false, ecosystem = self.class.name.demodulize.downcase)
      deps.map do |k, v|
        {
          package_name: k,
          requirements: v,
          kind: kind,
          optional: optional,
          ecosystem: ecosystem,
        }
      end
    end

    def find_and_map_dependencies(name, version, _package)
      dependencies = find_dependencies(name, version)
      return [] unless dependencies&.any?

      dependencies.map do |dependency|
        dependency = dependency.is_a?(Bibliothecary::Dependency) ? dependency.to_h : dependency.deep_stringify_keys
        {
          package_name: dependency[:name] || dependency["name"],
          requirements: dependency[:requirement] || dependency["requirement"] || "*",
          kind: dependency[:type] || dependency["type"],
          ecosystem: self.class.name.demodulize.downcase,
        }
      end
    end

    def repo_fallback(repo, homepage)
      repo = "" if repo.nil?
      homepage = "" if homepage.nil?
      repo_url = UrlParser.try_all(repo) rescue ""
      homepage_url = UrlParser.try_all(homepage) rescue ""
      if repo_url.present?
        repo_url
      elsif homepage_url.present?
        homepage_url
      else
        repo
      end
    end

    def find_repository_url(urls)
      return nil if urls.nil?
      urls.map do |url|
        UrlParser.try_all(url) rescue nil
      end.compact.reject{|u| u.include?('github.com/sponsors') }.first
    end

    def package_find_names(package_name)
      [package_name]
    end

    def deprecation_info(_name)
      { is_deprecated: false, message: nil }
    end

    def maintainers_metadata(name)
      []
    end

    def purl(package, version = nil)
      params = purl_params(package, version)

      # Add repository_url to qualifiers if non-default registry
      # default: true means it's the default registry for that ecosystem
      # nil or false means it's not the default and should include repository_url
      if @registry.default != true
        params[:qualifiers] ||= {}
        params[:qualifiers]['repository_url'] = @registry_url
      end

      Purl::PackageURL.new(**params).to_s
    rescue => e
      # invalid encoding or other errors
      nil
    end

    def purl_params(package, version = nil)
      {
        type: purl_type,
        namespace: nil,
        name: package.name.encode('iso-8859-1'),
        version: version.try(:number).try(:encode,'iso-8859-1')
      }
    end

    def purl_type
      self.class.purl_type
    end

    def self.purl_type
      name.demodulize.downcase
    end

    def self.namespace_separator
      '/'
    end

    def self.purl_type_to_ecosystem(purl_type)
      list.find { |p| p.purl_type == purl_type }.try(:lowercase_name)
    end

    def self.purl_type_to_namespace_separator(purl_type)
      list.find { |p| p.purl_type == purl_type }.try(:namespace_separator)
    end

    def namespace_package_names(namespace)
      []
    end

    def update_existing_versions(_package, _versions_metadata)
      nil
    end

    REPOS_TAGS_PER_PAGE = 1000

    def sync_tag_backed_versions(package, versions_metadata)
      return if versions_metadata.blank?

      remote = versions_metadata.each_with_object({}) do |version, result|
        version = version.with_indifferent_access
        result[version[:number].to_s.downcase] = version
      end
      mark_removed = versions_metadata.size < REPOS_TAGS_PER_PAGE
      now = Time.current

      package.versions.select(:id, :number, :status, :published_at, :metadata).find_each do |version|
        incoming = remote[version.number.to_s.downcase]
        if incoming.nil?
          next unless mark_removed
          next if version.status == 'removed'
          version.update_columns(status: 'removed', updated_at: now)
          next
        end

        updates = {}
        updates[:status] = nil if version.status == 'removed'

        incoming_metadata = (incoming[:metadata] || {}).with_indifferent_access
        existing_metadata = (version.metadata || {}).with_indifferent_access
        if incoming_metadata[:sha].present? && incoming_metadata[:sha] != existing_metadata[:sha]
          new_metadata = existing_metadata.merge('sha' => incoming_metadata[:sha])
          new_metadata['download_url'] = incoming_metadata[:download_url] if incoming_metadata[:download_url].present?
          updates[:metadata] = new_metadata
          updates[:published_at] = incoming[:published_at] if incoming[:published_at].present?
        end

        version.update_columns(updates.merge(updated_at: now)) if updates.any?
      end
    end

    def merge_version_metadata(_existing_metadata, new_metadata)
      new_metadata
    end

    def download_and_cache(url, cache_key, ttl: 1.hour)
      cache_dir = Rails.root.join('tmp', 'cache', 'ecosystems')
      FileUtils.mkdir_p(cache_dir)
      cached_file = cache_dir.join(cache_key)

      if cached_file.exist? && cached_file.mtime > ttl.ago
        return cached_file
      end

      Dir.mktmpdir do |dir|
        `wget -q -P #{dir} #{url}`
        downloaded = Dir.glob("#{dir}/*").first

        if downloaded.nil? || !File.exist?(downloaded)
          Rails.logger.error "Failed to download from #{url}: wget returned no files, deleting stale cache if exists"
          File.delete(cached_file) if cached_file.exist?
          return nil
        end

        if downloaded.end_with?('.tar.gz')
          `tar -xzf #{downloaded} -C #{dir}`
          extracted = Dir.glob("#{dir}/*").reject { |f| f.end_with?('.tar.gz') }.first

          if extracted.nil?
            Rails.logger.error "Failed to extract #{downloaded}: no files found after extraction, deleting stale cache if exists"
            File.delete(cached_file) if cached_file.exist?
            return nil
          end

          FileUtils.cp(extracted, cached_file)
        else
          FileUtils.cp(downloaded, cached_file)
        end
      end

      unless cached_file.exist?
        Rails.logger.error "Failed to create cache file #{cached_file} from #{url}"
        return nil
      end

      cached_file
    end

    def parse_apkindex(file, repository = nil)
      return [] if file.nil? || !File.exist?(file)

      packages = []
      package = repository ? {'r' => repository} : {}

      File.foreach(file) do |line|
        if line.blank?
          packages << package
          package = repository ? {'r' => repository} : {}
        end
        key = line.split(':')[0]
        value = line.split(':')[1..-1].join(':').strip
        package[key] = value if key.present?
      end
      packages << package if package['P'].present?
      packages
    end

    private

    def get_raw_no_exception(url, options = {})
      resp = request(url, options)
      return nil unless resp.success?
      resp.body
    end

    def get_raw(url, options = {})
      request(url, options).body
    end

    def request(url, options = {})
      options[:headers] ||= {}
      options[:headers]["User-Agent"] = "packages.ecosyste.ms"
      # Add API key for ecosyste.ms domains
      if ENV['ECOSYSTEMS_API_KEY'] && url.include?('.ecosyste.ms')
        options[:headers]["X-API-Key"] = ENV['ECOSYSTEMS_API_KEY']
      end
      connection = Faraday.new url.strip, options do |builder|
        builder.use Faraday::FollowRedirects::Middleware
        builder.request :retry, { max: 2, interval: 0.05, interval_randomness: 0.5, backoff_factor: 2 }

        builder.request :instrumentation
        builder.adapter Faraday.default_adapter, accept_encoding: "gzip"

        builder.options.timeout = 10
        builder.options.open_timeout = 5
      end
      connection.get
    end

    def get(url, options = {})
      Oj.load(get_raw(url, options))
    end
    
    def get_html(url, options = {})
      Nokogiri::HTML(get_raw(url, options))
    end

    def get_xml(url, options = {})
      Nokogiri::XML(get_raw(url, options))
    end

    def get_json(url, options = {})
      options.deep_merge!(headers: { "Accept" => "application/json" })
      get(url, options)
    end

    def get_json_array(url, options = {})
      json = get_json(url, options)
      json.is_a?(Array) ? json : []
    end
  end
end