if Rails.env.development?
           config.hosts = []
           config.hosts << "polly.pollitify:3000"
         end

    module Polly
      class Application < Rails::Application

    # comment this next line out if it exists for you
    # config.active_record.migration_error = :page_load
    # Disable automatic pending migration check in development
    config.active_record.migration_error = false

    class CreateTenants < ActiveRecord::Migration[8.0]
      def change
        create_table :tenants do |t|
          t.string :domain, null: false
          t.string :database_name, null: false
          t.string :company_name
          t.boolean :active, default: true
          t.json :settings
          t.timestamps
        end

        add_index :tenants, :domain, unique: true
        add_index :tenants, :database_name, unique: true
      end
    end

class Tenant < TenantConnection #TempConnection #< ApplicationRecord
  
  validates :domain, presence: true, uniqueness: true
  validates :database_name, presence: true, uniqueness: true
  
  before_validation :set_database_name, on: :create
  
  # Example method that connects to the tenant’s DB for a given block
  def with_connection
    config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: database_name)
    raise "No config found for #{database_name}" unless config

    ActiveRecord::Base.connected_to(database: { writing: database_name }) do
      yield
    end
  end
  
  # Tenant.get_database_name_from_host("polly.pollitify")
  def self.get_database_name_from_host(domain)
    "polly_#{Tenant.strip_www(domain).gsub(/[^a-z0-9]/i, '_').downcase}_#{Rails.env}"
  end
  
  def self.strip_www(domain)
    domain.sub(/^www./,'')
  end
  
  def switch!
    TenantConnection.switch!(database_name)
  end

  def connection_config
    if Rails.env.production?
      # In production, build config from DATABASE_URL pattern
      # but override the database name
      base_config = ActiveRecord::Base.connection_db_config.configuration_hash
      base_config.merge(database: database_name)
    else
      # In development/test, use explicit config
      Rails.configuration.database_configuration[Rails.env]['primary']
        .merge('database' => database_name)
    end
  end

  private

  def set_database_name
    # Convert domain to safe database name
    # e.g., "client.example.com" -> "polly_client_example_com_development"
    self.database_name ||= Tenant.get_database_name_from_host(domain)
  end
end

class TenantConnection < ActiveRecord::Base
  self.abstract_class = true

  # All models inheriting from this connect to the registry by default
  connects_to database: { writing: :registry, reading: :registry }
  
  # Switch to a tenant or named database dynamically
  #
  # Works for:
  #   TenantConnection.switch!("registry")     # from database.yml
  #   TenantConnection.switch!("tenant_123")   # dynamic tenant
  #   TenantConnection.switch!(hash_config)    # full hash
  #
  def self.switch!(config_or_name)
    config =
      case config_or_name
      when String, Symbol
        lookup_config(config_or_name.to_s) || build_dynamic_config(config_or_name.to_s)
      when Hash
        config_or_name
      else
        raise ArgumentError, "Invalid config_or_name: #{config_or_name.inspect}"
      end

    raise ArgumentError, "No configuration found for #{config_or_name}" unless config

    establish_connection(config)
    connection  # <-- return actual connection
  end

  # Look up a named connection from database.yml 
  def self.lookup_config(name)
    configurations = ActiveRecord::Base.configurations
    return nil unless configurations.respond_to?(:configs_for)

    configs = configurations.configs_for(env_name: Rails.env, name: name)
    db_config =
      case configs
      when ActiveRecord::DatabaseConfigurations::HashConfig
        configs
      when Array
        configs.first
      end

    db_config&.configuration_hash
  rescue => e
    warn "lookup_config failed for #{name}: #{e.message}"
    nil
  end

  # Build a runtime tenant configuration when it's not in database.yml
  def self.build_dynamic_config(db_name)
    configurations = ActiveRecord::Base.configurations
    primary = configurations.configs_for(env_name: Rails.env, name: "primary")

    # Handle both Array and single HashConfig return types
    primary_config =
      case primary
      when ActiveRecord::DatabaseConfigurations::HashConfig
        primary
      when Array
        primary.first
      else
        nil
      end

    # Fallback to the environment’s top-level config if no primary exists
    unless primary_config
      env_configs = configurations.configs_for(env_name: Rails.env)
      primary_config =
        case env_configs
        when ActiveRecord::DatabaseConfigurations::HashConfig
          env_configs
        when Array
          env_configs.first
        else
          nil
        end
    end

    raise "Primary database configuration not found" unless primary_config

    config = primary_config.configuration_hash.deep_dup
    config[:database] = db_name
    config
  end

  # Optionally helpful for debugging
  def self.current_database
    connection_db_config.database
  end

  def self.clear!
    connection_pool.disconnect!
    establish_connection(:primary)
    true
  end

end

# test/models/tenant_test.rb
require "test_helper"

class TenantTest < ActiveSupport::TestCase
  use_registry
  
  test "creates tenant with valid domain" do
    tenant = Tenant.create!(domain: "test.example.com")
    assert_equal "polly_test_example_com_test", tenant.database_name
  end
  
  test "validates uniqueness of domain" do
    Tenant.create!(domain: "test.example.com")
    duplicate = Tenant.new(domain: "test.example.com")
    assert_not duplicate.valid?
  end
  
  test "gets the domain name from the host name for fully qualified domain name" do 
    db_name = Tenant.get_database_name_from_host("helpfulhippie.com")
    assert_equal "polly_helpfulhippie_com_test", db_name
  end
  
  test "gets the domain name from the host name for fully qualified domain name and deals with www correctly" do 
    db_name = Tenant.get_database_name_from_host("www.helpfulhippie.com")
    assert_equal "polly_helpfulhippie_com_test", db_name
  end
  
  test "gets the domain name from the host name for a subdomain" do 
    db_name = Tenant.get_database_name_from_host("cassjackson.47muppet.com")
    assert_equal "polly_cassjackson_47muppet_com_test", db_name
  end
end

# test/models/tenant_connection_test.rb
require "test_helper"

# test/models/tenant_connection_test.rb
require "test_helper"

class TenantConnectionTest < ActiveSupport::TestCase
  self.use_transactional_tests = false
  
  setup do
    @tenant_name = "tenant_test_db_for_test"

    # Ensure we start with a clean database
    drop_tenant_db(@tenant_name) rescue nil
    create_tenant_db(@tenant_name)

    # Minimal tenant config pointing to the real Postgres DB
    @tenant_config = {
      "adapter"  => "postgresql",
      "database" => @tenant_name,
      "username" => ENV['PGUSER'] || "postgres",
      "password" => ENV['PGPASSWORD'] || nil,
      "host"     => ENV['PGHOST'] || "localhost",
      "port"     => ENV['PGPORT'] || 5432
    }

    @hash_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(
      Rails.env, @tenant_name, @tenant_config
    )
    
    @registry_config = ActiveRecord::DatabaseConfigurations::HashConfig.new(
      Rails.env,
      "registry",
      {
        "adapter"  => "postgresql",
        "database" => "registry_test_db",
        "username" => ENV['PGUSER'] || "postgres",
        "password" => ENV['PGPASSWORD'] || nil,
        "host"     => ENV['PGHOST'] || "localhost",
        "port"     => ENV['PGPORT'] || 5432
      }
    )
  end

  teardown do
    drop_tenant_db(@tenant_name) rescue nil
  end

  test "switch! allows inserts and queries on the tenant database" do
    with_real_db_configuration([@registry_config, @hash_config]) do
      # Switch to the tenant DB
      TenantConnection.switch!(@hash_config.configuration_hash)
      
      # Use a temporary model to test inserts
      klass = Class.new(ActiveRecord::Base) do
        self.table_name = "temp_test_table"
      end

      # Create a table in the tenant DB
      klass.connection.create_table(:temp_test_table) do |t|
        t.string :name
      end

      # Insert a record
      klass.create!(name: "Test Record")

      # Query it back
      record = klass.first
      assert_equal "Test Record", record.name

      # Drop the table to clean up
      klass.connection.drop_table(:temp_test_table)
    end
  end

  private

  # Temporarily overrides configurations to return a real DB config
  def with_real_db_configuration(configs)
    original = ActiveRecord::Base.configurations
    fake = StubConfigs.new(configs)
    ActiveRecord::Base.singleton_class.prepend(Module.new {
      define_method(:configurations) { fake }
    })
    yield
  ensure
    ActiveRecord::Base.singleton_class.prepend(Module.new {
      define_method(:configurations) { original }
    })
  end

  # Helpers to create/drop tenant databases
  def create_tenant_db(name)
    ActiveRecord::Base.establish_connection(Rails.env.to_sym)
    ActiveRecord::Base.connection.create_database(name)
  end

  def drop_tenant_db(name)
    ActiveRecord::Base.establish_connection(Rails.env.to_sym)
    ActiveRecord::Base.connection.drop_database(name)
  end
end

# Minimal stub class to mimic Rails configurations
class StubConfigs
  def initialize(configs)
    @configs = configs
  end

  # Rails calls this to get a list of matching configs
  def configs_for(env_name:, name:)
    @configs
  end
  
  # Rails 8 sometimes calls this to check if a config set represents the primary database
  def primary?(*)
    false
  end

  # Rails 8 calls this with either:
  # - a HashConfig (already resolved)
  # - a Hash (legacy style)
  # - a String or Symbol (new behavior)
  def resolve(config)
    case config
    when ActiveRecord::DatabaseConfigurations::HashConfig
      config
    when Hash
      ActiveRecord::DatabaseConfigurations::HashConfig.new(
        Rails.env,
        config["database"] || "stub_db",
        config
      )
    when String, Symbol
      found = @configs.find { |c| c.name.to_s == config.to_s }
      if found
        found
      else
        raise "No configuration found for #{config.inspect}"
      end
    else
      raise "Unexpected config type: #{config.class.name}"
    end
  end
end

class ActiveSupport::TestCase
  include Devise::Test::IntegrationHelpers
  
  def setup
    setup_registry if self.class.use_registry?
  end
  
  def self.use_registry
    @use_registry = true
  end
  
  def self.use_registry?
    @use_registry
  end
  
  private
  
  # Setup registry database before tests
  def setup_registry
    TenantConnection.connection    
  end  
end

namespace :test do
  desc "Prepare registry database for testing"
  task prepare_registry: :environment do
    Rails.env = "test"
    
    # Get the registry database configuration
    db_config = ActiveRecord::Base.configurations.configs_for(env_name: "test", name: "registry")
    
    # Create the database if it doesn't exist
    ActiveRecord::Tasks::DatabaseTasks.create(db_config)
    
    # Establish connection to registry
    ActiveRecord::Base.establish_connection(db_config)
    
    # Ensure schema_migrations table exists
    unless ActiveRecord::Base.connection.table_exists?(:schema_migrations)
      ActiveRecord::Base.connection.create_table :schema_migrations, id: false do |t|
        t.string :version, null: false, primary_key: true
      end
    end
    
    # Run migrations from the registry migrations folder
    migrations_path = Rails.root.join("db/registry_migrate")
    
    if migrations_path.exist?
      puts "Running migrations from #{migrations_path}"
      ActiveRecord::Migration.verbose = true
      
      # Get all migration files
      migration_files = Dir[migrations_path.join("*.rb")].sort
      
      migration_files.each do |file|
        version = File.basename(file).split('_').first
        
        # Check if already migrated
        unless ActiveRecord::Base.connection.select_values("SELECT version FROM schema_migrations").include?(version)
          puts "Running migration #{File.basename(file)}"
          load file
          
          # Get the migration class name from the file
          migration_name = File.basename(file, '.rb').split('_')[1..-1].join('_').camelize
          migration_class = migration_name.constantize
          
          migration_class.new.migrate(:up)
          
          # Record migration
          ActiveRecord::Base.connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
        end
      end
    end
    
    # Disconnect
    ActiveRecord::Base.connection_pool.disconnect!
  end
end

class ApplicationController < ActionController::Base
  
  #around_action :switch_tenant_database
  around_action :switch_tenant, unless: -> { Rails.env.test? }
  
  private
  
  def switch_tenant
    tenant = Tenant.find_by(domain: Tenant.strip_www(request.host))
    raise ActiveRecord::RecordNotFound, "Tenant not found" unless tenant

    # Dynamically establish the connection
    tenant_config = ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary")

    db_config = tenant_config.configuration_hash.merge(
      "database" => tenant.database_name
    )

    ActiveRecord::Base.establish_connection(db_config)

    yield
  ensure
    # Reset back to registry after request
    ActiveRecord::Base.establish_connection(:primary)
  end
  
end

# lib/tasks/tenants.rake

=begin
rake tenants:create[domain,company_name]                 # Create a new tenant database
rake tenants:create_from_legacy[domain]                  # Create initial tenant from legacy database
rake tenants:drop[domain]                                # Drop a tenant database (DANGEROUS)
rake tenants:list                                        # List all tenants
rake tenants:migrate                                     # Run migrations for all tenant databases
rake tenants:migrate_registry                            # Migrate registry database
rake tenants:seed                                        # Run custom seed for all tenants
rake tenants:seed_one[domain]                            # Run custom seed for specific tenant
rake tenants:setup_registry                              # Setup registry database

=end

namespace :tenants do
  # DONE AND TESTED
  # bundle exec rake tenants:setup_registry --trace
  desc "Setup registry database"
  task setup_registry: :environment do
    registry_config = get_registry_config
    
    puts "\n=== Registry Database Setup ==="
    puts "Database: #{registry_config['database'] || registry_config['url']}"
    
    puts "\nCreating registry database..."
    begin
      ActiveRecord::Tasks::DatabaseTasks.create(registry_config)
      puts "✓ Registry database created"
    rescue ActiveRecord::DatabaseAlreadyExists
      puts "✓ Registry database already exists"
    end
    
    puts "\nRunning registry migrations..."
    
    original_config = ActiveRecord::Base.connection_db_config
    
    begin
      puts "→ Connecting to: #{registry_config['database']}"
      ActiveRecord::Base.establish_connection(registry_config)
      
      # Verify connection
      connection = ActiveRecord::Base.connection
      puts "✓ Connected to database: #{connection.current_database}"
      
      # Ensure migrations directory exists
      migrations_path = Rails.root.join("db/registry_migrate")
      puts "→ Registry migrations path: #{migrations_path}"
      FileUtils.mkdir_p(migrations_path) unless Dir.exist?(migrations_path)
      
      # Check for migration files
      migration_files = Dir[migrations_path.join("*.rb")].sort
      puts "→ Found #{migration_files.count} migration file(s)"
      migration_files.each { |f| puts "  - #{File.basename(f)}" }
      
      # Create schema_migrations table if it doesn't exist
      unless connection.table_exists?(:schema_migrations)
        puts "→ Creating schema_migrations table..."
        connection.execute(<<-SQL)
          CREATE TABLE IF NOT EXISTS schema_migrations (
            version varchar NOT NULL PRIMARY KEY
          );
        SQL
        puts "✓ Schema migrations table created"
      end
      
      # Create ar_internal_metadata table if it doesn't exist
      unless connection.table_exists?(:ar_internal_metadata)
        puts "→ Creating ar_internal_metadata table..."
        connection.execute(<<-SQL)
          CREATE TABLE IF NOT EXISTS ar_internal_metadata (
            key varchar NOT NULL PRIMARY KEY,
            value varchar,
            created_at timestamp(6) NOT NULL,
            updated_at timestamp(6) NOT NULL
          );
        SQL
        
        connection.execute(<<-SQL)
          INSERT INTO ar_internal_metadata (key, value, created_at, updated_at)
          VALUES ('environment', '#{Rails.env}', NOW(), NOW())
          ON CONFLICT (key) DO NOTHING;
        SQL
        puts "✓ Internal metadata table created"
      end
      
      # Get already-run migrations
      migrated_versions = connection.select_values("SELECT version FROM schema_migrations")
      puts "→ Already migrated: #{migrated_versions.count} version(s)"
      
      # Run pending migrations manually
      migration_files.each do |migration_file|
        # Extract version from filename (e.g., "20250107000001_create_tenants.rb" -> "20250107000001")
        version = File.basename(migration_file).split('_').first
        
        if migrated_versions.include?(version)
          puts "  ⊘ Skipping #{File.basename(migration_file)} (already migrated)"
          next
        end
        
        puts "  → Running #{File.basename(migration_file)}..."
        
        begin
          # Load the migration file
          load migration_file
          
          # Extract the class name from the filename
          # e.g., "20250107000001_create_tenants.rb" -> "CreateTenants"
          class_name = File.basename(migration_file, '.rb').split('_')[1..-1].map(&:capitalize).join
          
          # Get the migration class
          migration_class = class_name.constantize
          
          # Run the migration
          migration_instance = migration_class.new
          migration_instance.migrate(:up)
          
          # Record the migration
          connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
          
          puts "  ✓ Migrated #{File.basename(migration_file)}"
        rescue => e
          puts "  ✗ Failed to run #{File.basename(migration_file)}"
          puts "  Error: #{e.class} - #{e.message}"
          raise e
        end
      end
      
      puts "✓ Registry setup complete"
    rescue => e
      puts "\n✗ Error during registry migration"
      puts "Database: #{registry_config['database']}"
      puts "Error: #{e.class} - #{e.message}"
      puts "\nBacktrace:"
      puts e.backtrace.first(15).map { |line| "  #{line}" }.join("\n")
      exit 1
    ensure
      ActiveRecord::Base.establish_connection(original_config.configuration_hash)
    end
  end
















  # DONE AND TESTED
  # bundle exec rake tenants:migrate_registry --trace
  desc "Migrate registry database"
  task migrate_registry: :environment do
    registry_config = get_registry_config
    
    puts "\n=== Migrating Registry Database ==="
    puts "Database: #{registry_config['database'] || registry_config['url']}"
    
    original_config = ActiveRecord::Base.connection_db_config
    
    begin
      ActiveRecord::Base.establish_connection(registry_config)
      connection = ActiveRecord::Base.connection
      puts "✓ Connected to: #{connection.current_database}"
      
      migrations_path = Rails.root.join("db/registry_migrate")
      migration_files = Dir[migrations_path.join("*.rb")].sort
      
      # Get already-run migrations
      migrated_versions = connection.select_values("SELECT version FROM schema_migrations")
      
      # Run pending migrations
      migration_files.each do |migration_file|
        version = File.basename(migration_file).split('_').first
        
        if migrated_versions.include?(version)
          puts "⊘ Skipping #{File.basename(migration_file)}"
          next
        end
        
        puts "→ Running #{File.basename(migration_file)}..."
        
        load migration_file
        class_name = File.basename(migration_file, '.rb').split('_')[1..-1].map(&:capitalize).join
        migration_class = class_name.constantize
        migration_instance = migration_class.new
        migration_instance.migrate(:up)
        
        connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
        puts "✓ Migrated #{File.basename(migration_file)}"
      end
      
      puts "✓ Registry migrated"
    rescue => e
      puts "\n✗ Error migrating registry"
      puts "Database: #{registry_config['database']}"
      puts "Error: #{e.class} - #{e.message}"
      puts "\nBacktrace:"
      puts e.backtrace.first(15).map { |line| "  #{line}" }.join("\n")
      exit 1
    ensure
      ActiveRecord::Base.establish_connection(original_config.configuration_hash)
    end
  end











  # bundle exec rake tenants:migrate--trace
  desc "Run migrations for all tenant databases"
  task migrate: :environment do
    puts "\n=== Migrating All Tenant Databases ==="
    
    tenants = Tenant.where(active: true).to_a
    puts "Found #{tenants.count} active tenant(s)\n"
    
    migrated = 0
    failed = 0
    failed_tenants = []
    
    migrations_path = Rails.root.join("db/migrate")
    migration_files = Dir[migrations_path.join("*.rb")].sort
    
    tenants.each do |tenant|
      puts "\n" + "="*60
      puts "→ Tenant: #{tenant.domain}"
      puts "  Database: #{tenant.database_name}"
      puts "="*60
      
      begin
        connection = TenantConnection.switch!(tenant.database_name)
        #connection = ActiveRecord::Base.connection
        current_db = connection.current_database
        puts "  ✓ Connected to: #{current_db}"
        
        unless current_db == tenant.database_name
          raise "Database mismatch! Expected #{tenant.database_name}, got #{current_db}"
        end
        
        # Ensure schema_migrations exists
        unless connection.table_exists?(:schema_migrations)
          puts "  → Creating schema_migrations table..."
          connection.execute(<<-SQL)
            CREATE TABLE IF NOT EXISTS schema_migrations (
              version varchar NOT NULL PRIMARY KEY
            );
          SQL
        end
        
        # Get already-run migrations
        migrated_versions = connection.select_values("SELECT version FROM schema_migrations")
        
        # Run pending migrations
        migration_files.each do |migration_file|
          version = File.basename(migration_file).split('_').first
          
          next if migrated_versions.include?(version)
          
          puts "  → Running #{File.basename(migration_file)}..."
          
          load migration_file
          class_name = File.basename(migration_file, '.rb').split('_')[1..-1].map(&:capitalize).join
          migration_class = class_name.constantize
          
          # make migration use TenantConnection, not ActiveRecord::Base
          migration_class = Class.new(migration_class) do
            def connection
              TenantConnection.connection
            end
          end

          migration_instance = migration_class.new
          migration_instance.migrate(:up)

          TenantConnection.connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
          puts "  ✓ Migrated"
          
          # migration_instance = migration_class.new
          # migration_instance.migrate(:up)
          #
          # connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
          # puts "  ✓ Migrated"
        end
        
        puts "  ✓ Success"
        migrated += 1
      rescue => e
        puts "  ✗ Failed"
        puts "  Error: #{e.class}"
        puts "  Message: #{e.message}"
        
        # Show the exact file and line where the error originated
        if e.backtrace && e.backtrace.any?
          file_line = e.backtrace.first
          puts "  Location: #{file_line}"
        end
        
        puts "  This might be the same or more helpful: "
        app_trace = e.backtrace.find { |line| line.include?(Rails.root.to_s) }
        puts "    Our Code Location: #{app_trace || e.backtrace.first}"
        
        if ENV['VERBOSE']
          puts "\n  Backtrace:"
          puts e.backtrace.first(10).map { |line| "    #{line}" }.join("\n")
        end
        failed += 1
        failed_tenants << { tenant: tenant, error: e }
      ensure
        TenantConnection.clear!
      end
    end
    
    puts "\n" + "="*60
    puts "=== Migration Summary ==="
    puts "="*60
    puts "Total tenants: #{tenants.count}"
    puts "Migrated successfully: #{migrated}"
    puts "Failed: #{failed}"
    
    if failed_tenants.any?
      puts "\nFailed Tenants:"
      failed_tenants.each do |failure|
        puts "  ✗ #{failure[:tenant].domain} (#{failure[:tenant].database_name})"
        puts "    #{failure[:error].message}"
      end
    end
  end
  
  
  
  
  
  
  
  
  # bundle exec rake tenants:count_tables_per_tenant --trace
  desc "count tables per tenant"
  task count_tables_per_tenant: :environment do 
    tenants = Tenant.where(active: true).to_a
    puts "Found #{tenants.count} active tenant(s)\n"
    
    tenants.each do |tenant|
      tenant.switch!
      count = TenantConnection.connection.tables.count
      puts "#{tenant.database_name} --- #{count}"
    end
  end
  
  desc "count migrations ran per tenant"
  task count_migrations_ran_per_tenant: :environment do 
    tenants = Tenant.where(active: true).to_a
    puts "Found #{tenants.count} active tenant(s)\n"
    
    tenants.each do |tenant|
      tenant.switch!
      count = TenantConnection.connection.execute("SELECT COUNT(*) FROM schema_migrations").first["count"]
      puts "#{tenant.database_name} --- #{count}"
    end
  end
  
  

  # bundle exec rake tenants:insert_without_migrations\[polly.pollitify,pollitify\] --trace
  desc "Create tenant without running migrations"
  task :insert_without_migrations, [:domain,:company,:database] => :environment do |t, args|
    domain = args[:domain] || 'legacy.yourdomain.com'
    company = args[:company] || domain
    database = args[:database] || ''
    
    raise "Database MUST be specified" if database.blank?
    
    puts "\n=== Creating Tenant from Legacy Database ==="
    puts "Domain: #{domain}"
    puts "Company: #{company}"
    puts "Database: #{database}"
    puts ""
    print "Continue? (y/n): "
    
    response = STDIN.gets.chomp
    exit unless response.downcase == 'y'
    
    tenant = Tenant.create!(
      domain: domain,
      database_name: database,
      company_name: company
    )
    puts "✓ Created tenant record (ID: #{tenant.id})"
  end


  
  
  
  # bundle exec rake tenants:create_from_legacy\[polly.pollitify\] --trace
  desc "Create initial tenant from legacy database"
  task :create_from_legacy, [:domain] => :environment do |t, args|
    domain = args[:domain] || 'legacy.yourdomain.com'
    
    #new_db_name = "polly_#{domain.gsub(/[^a-z0-9]/i, '_').downcase}"
    new_db_name = Tenant.get_database_name_from_host(domain)
    
    puts "\n=== Creating Tenant from Legacy Database ==="
    puts "Domain: #{domain}"
    puts "Current DB: polly2_take20aaa_#{Rails.env}"
    puts "New DB: #{new_db_name}"
    puts ""
    print "Continue? (y/n): "
    
    response = STDIN.gets.chomp
    exit unless response.downcase == 'y'
    
    tenant = Tenant.create!(
      domain: domain,
      database_name: new_db_name,
      company_name: 'Legacy Client'
    )
    puts "✓ Created tenant record (ID: #{tenant.id})"
    
    puts "\n⚠️  Close all connections to the database now!"
    puts "Press Enter when ready..."
    STDIN.gets
    
    old_db = "polly2_take20aaa_#{Rails.env}"
    
    begin
      puts "→ Terminating existing connections to #{old_db}..."
      ActiveRecord::Base.connection.execute(<<-SQL)
        SELECT pg_terminate_backend(pg_stat_activity.pid)
        FROM pg_stat_activity
        WHERE pg_stat_activity.datname = '#{old_db}'
          AND pid <> pg_backend_pid();
      SQL
      
      puts "→ Renaming database..."
      ActiveRecord::Base.connection.execute(
        "ALTER DATABASE #{old_db} RENAME TO #{new_db_name};"
      )
      
      puts "✓ Renamed database: #{old_db} → #{new_db_name}"
      
      puts "\n⚠️  IMPORTANT: Update your database.yml:"
      puts "  Change 'database: #{old_db}'"
      puts "  To:     'database: #{new_db_name}'"
      
    rescue => e
      puts "✗ Failed to rename database"
      puts "Error: #{e.class} - #{e.message}"
      puts "\nYou may need to do this manually:"
      puts "  ALTER DATABASE #{old_db} RENAME TO #{new_db_name};"
      tenant.destroy
      exit 1
    end
  end
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  #bundle exec rake tenants:create\[helpfulhippie.com,HelpfulHippie\]
  desc "Create a new tenant database"
  task :create, [:domain, :company_name] => :environment do |t, args|
    domain = args[:domain]
    raise "Domain required: rails tenants:create[example.com]" unless domain
    
    puts "\n=== Creating New Tenant ==="
    puts "Domain: #{domain}"
    puts "Company: #{args[:company_name] || '(not specified)'}"
    
    tenant = Tenant.new(domain: domain, company_name: args[:company_name])
    
    if tenant.save
      puts "✓ Tenant record created"
      puts "  ID: #{tenant.id}"
      puts "  Database: #{tenant.database_name}"
      
      puts "\n→ Creating database: #{tenant.database_name}..."
      config = tenant.connection_config
      ActiveRecord::Tasks::DatabaseTasks.create(config)
      puts "✓ Database created"
      
      puts "\n→ Running migrations..."
      tenant.switch!
      
      current_db = ActiveRecord::Base.connection.current_database
      puts "✓ Connected to: #{current_db}"
      
      connection = ActiveRecord::Base.connection
      unless connection.table_exists?(:schema_migrations)
        connection.execute(<<-SQL)
          CREATE TABLE IF NOT EXISTS schema_migrations (
            version varchar NOT NULL PRIMARY KEY
          );
        SQL
      end
      
      # Run migrations manually
      migrations_path = Rails.root.join("db/migrate")
      migration_files = Dir[migrations_path.join("*.rb")].sort
      
      # migration_files.each do |migration_file|
      #   version = File.basename(migration_file).split('_').first
      #
      #   puts "→ Running #{File.basename(migration_file)}..."
      #   load migration_file
      #   class_name = File.basename(migration_file, '.rb').split('_')[1..-1].map(&:capitalize).join
      #   migration_class = class_name.constantize
      #   migration_instance = migration_class.new
      #   migration_instance.migrate(:up)
      #
      #   connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
      # end
      
      migration_files.each do |migration_file|
        version = File.basename(migration_file).split('_').first

        puts "→ Running #{File.basename(migration_file)}..."
        load migration_file

        begin
          class_name = File.basename(migration_file, '.rb')
                        .split('_')[1..-1]
                        .join('_')
                        .camelize
          migration_class = class_name.constantize
        rescue NameError
          # fallback for gem migrations with namespaces or unexpected names
          migration_class = ObjectSpace.each_object(Class).find do |klass|
            klass < ActiveRecord::Migration && klass.name.present?
          end
        end

        migration_instance = migration_class.new
        migration_instance.migrate(:up)

        connection.execute("INSERT INTO schema_migrations (version) VALUES ('#{version}')")
      end
      
      
      TenantConnection.clear!
      
      puts "\n✓ Tenant created successfully"
      puts "  Domain: #{tenant.domain}"
      puts "  Database: #{tenant.database_name}"
      puts "  Company: #{tenant.company_name}"
    else
      puts "✗ Failed to create tenant:"
      tenant.errors.full_messages.each { |msg| puts "  - #{msg}" }
      exit 1
    end
  end
  
  
  
  
  
  
  
  
  
  
  
  # bundle exec rake tenants:seed
  desc "Run custom seed for all tenants"
  task seed: :environment do
    Tenant.where(active: true).find_each do |tenant|
      puts "\n→ Seeding #{tenant.domain} (#{tenant.database_name})..."
      tenant.switch!
      
      current_db = ActiveRecord::Base.connection.current_database
      puts "  Connected to: #{current_db}"
      
      if File.exist?(Rails.root.join('db', 'seeds.rb'))
        load Rails.root.join('db', 'seeds.rb')
        puts "  ✓ Seeded"
      else
        puts "  ⚠ No seeds.rb file found"
      end
      
      TenantConnection.clear!
    end
  end
  
  
  
  
  
  
  
  
  
  
  # bundle exec rake tenants:seed_one\[helpfulhippie.com]
  desc "Run custom seed for specific tenant"
  task :seed_one, [:domain] => :environment do |t, args|
    tenant = Tenant.find_by!(domain: args[:domain])
    
    puts "\n→ Seeding #{tenant.domain} (#{tenant.database_name})..."
    tenant.switch!
    
    current_db = ActiveRecord::Base.connection.current_database
    puts "  Connected to: #{current_db}"
    
    if File.exist?(Rails.root.join('db', 'seeds.rb'))
      load Rails.root.join('db', 'seeds.rb')
      puts "✓ Seeded #{tenant.domain}"
    else
      puts "✗ No seeds.rb file found"
    end
    
    TenantConnection.clear!
  end
  
  
  
  
  
  
  
  
  
  
  
  
  # bundle exec rake tenants:list
  desc "List all tenants"
  task list: :environment do
    puts "\n=== Tenants ==="
    tenants = Tenant.order(:domain).to_a
    
    if tenants.empty?
      puts "No tenants found"
    else
      tenants.each do |tenant|
        status = tenant.active? ? "✓" : "✗"
        puts "#{status} #{tenant.domain.ljust(30)} → #{tenant.database_name}"
      end
      puts "\nTotal: #{tenants.count} tenant(s)"
    end
  end
  
  
  
  
  
  
  
  
  
  
  
  # bundle exec rake tenants:drop\[helpfulhippie.com]
  desc "Drop a tenant database (DANGEROUS)"
  task :drop, [:domain] => :environment do |t, args|
    domain = args[:domain]
    raise "Domain required: rails tenants:drop[example.com]" unless domain
    
    tenant = Tenant.find_by!(domain: domain)
    
    puts "\n⚠️  WARNING: This will permanently delete the database for #{domain}"
    puts "Database: #{tenant.database_name}"
    print "Type the domain name to confirm: "
    
    confirmation = STDIN.gets.chomp
    if confirmation == domain
      puts "\n→ Dropping database..."
      config = tenant.connection_config
      ActiveRecord::Tasks::DatabaseTasks.drop(config)
      
      puts "→ Deleting tenant record..."
      tenant.destroy
      
      puts "✓ Dropped tenant database and record"
    else
      puts "✗ Confirmation failed. Aborted."
    end
  end
  
  
  
  
  
  
  
  # Helper method to get registry config
  def get_registry_config
    if Rails.env.production?
      if ENV['REGISTRY_DATABASE_URL'].present?
        {
          'adapter' => 'postgresql',
          'url' => ENV['REGISTRY_DATABASE_URL']
        }
      else
        raise "REGISTRY_DATABASE_URL environment variable not set"
      end
    else
      # Development or test
      db_configs = Rails.configuration.database_configuration
      env_config = db_configs[Rails.env]
      
      # Handle both flat and nested config structures
      registry_config = if env_config.is_a?(Hash) && env_config.key?('registry')
        env_config['registry']
      elsif env_config.is_a?(Hash) && env_config.key?(:registry)
        env_config[:registry]
      else
        # Fallback: manually build config
        {
          'adapter' => 'postgresql',
          'encoding' => 'unicode',
          'pool' => 5,
          'timeout' => 5000,
          'port' => 5432,
          'host' => 'localhost',
          'database' => "polly_registry_#{Rails.env}"
        }
      end
      
      registry_config
    end
  end
end