# frozen_string_literal: true

require 'active_record'

module CodeKindly
  module Utils
    class ActiveRecord
      include Deprecation

      RAILS = Kernel.const_defined?(:Rails) ? ::Rails : nil

      class << self
        def active_record_classes_by_connection
          deprecate :active_record_classes_by_connection,
                    :classes_by_connection,
                    :'0.1.0'
          classes_by_connection
        end

        def classes_by_connection
          @classes_by_connection ||= find_classes_by_connection
        end

        def clear_scope(scope)
          if scope.count.zero?
            puts 'Nothing to clear'
            return
          end
          puts "Clearing #{scope.count} #{scope.name} records"
          scope.delete_all
        end

        def config(name = nil)
          configs[name || default_name]
        end

        def configs
          @configs ||= ::ActiveRecord::Base.configurations
        end

        def configurations
          deprecate :configurations, :configs, :'0.1.0'
          configs
        end

        def default_connection_class(connection = nil)
          connection ||= default_name
          @default_connection_class ||= {}.with_indifferent_access
          @default_connection_class[connection] ||= begin
            it = classes_by_connection.fetch(connection, []).first
            key = classes_by_connection.keys.first
            it ||= classes_by_connection.fetch(key).first
            it
          end
        end

        private

        def application_active_record_class?(klass)
          return false unless klass < ::ActiveRecord::Base
          return false     if klass.abstract_class
          return false     if klass.name =~ /ActiveRecord::/
          return false     if Presence.blank?(klass.name)
          true
        rescue NoMethodError
          false
        end

        def default_name
          @default_name ||= RAILS.try(:env) || configs.keys.first || 'default'
        end

        # rubocop:disable Metrics/AbcSize
        def find_classes
          if RAILS.try(:env).try(:development?)
            model_files = RAILS.root.join('app', 'models').to_s + '/**/*.rb'
            ::Dir.glob(model_files) do |f|
              klass = ::File.basename(f, '.rb').classify
              next if Kernel.const_defined? klass

              require f
            end
          end
          ObjectSpace.each_object(Class).select do |klass|
            application_active_record_class?(klass)
          end.sort_by(&:name)
        end

        def find_classes_by_connection
          sets = {}.with_indifferent_access
          find_classes.each do |klass|
            config_name = configs.keys.select do |k|
              configs[k]['database'] == klass.connection.current_database
            end.first
            config_name ||= default_name
            sets[config_name] ||= []
            sets[config_name] << klass
          end
          sets
        end
        # rubocop:enable Metrics/AbcSize
      end
    end
  end
end