# Bad example: Violates Single Responsibility Principle (SRP)
class OrderProcessor
  def process_order(order_data)
    # Validate order data
    puts "Validating order: #{order_data[:id]}"
    if order_data[:items].empty?
      puts "Order has no items. Aborting."
      return false
    end

    # Calculate total price
    total_price = order_data[:items].sum { |item| item[:price] * item[:quantity] }
    puts "Calculated total price: $#{total_price}"

    # Persist order to database
    # Imagine complex ActiveRecord logic here, e.g., creating Order and OrderItem records
    puts "Saving order #{order_data[:id]} to database..."
    # Order.create!(order_data.merge(total: total_price))

    # Send confirmation email
    puts "Sending confirmation email for order #{order_data[:id]}..."
    # Mailer.send_order_confirmation(order_data[:email], order_data[:id], total_price)

    true
  end
end

# Refactored example: Adheres to SRP, promoting maintainability and testability
class OrderValidator
  def validate(order_data)
    order_data[:items].any?
  end
end

class PriceCalculator
  def calculate_total(items)
    items.sum { |item| item[:price] * item[:quantity] }
  end
end

class OrderRepository
  def save(order_data, total_price)
    # Logic to persist order to database
    puts "Saving order #{order_data[:id]} with total $#{total_price} to database..."
    # Order.create!(order_data.merge(total: total_price))
  end
end

class OrderNotifier
  def send_confirmation(email, order_id, total_price)
    # Logic to send confirmation email
    puts "Sending confirmation email for order #{order_id} to #{email}..."
    # Mailer.send_order_confirmation(email, order_id, total_price)
  end
end

class CleanOrderProcessor
  def initialize(validator: OrderValidator.new, calculator: PriceCalculator.new,
                 repository: OrderRepository.new, notifier: OrderNotifier.new)
    @validator = validator
    @calculator = calculator
    @repository = repository
    @notifier = notifier
  end

  def process_order(order_data)
    puts "Processing order: #{order_data[:id]}"
    unless @validator.validate(order_data)
      puts "Order validation failed for #{order_data[:id]}. Aborting."
      return false
    end

    total_price = @calculator.calculate_total(order_data[:items])
    @repository.save(order_data, total_price)
    @notifier.send_confirmation(order_data[:email], order_data[:id], total_price)

    true
  end
end

# --- Usage Examples ---
puts "\n--- Bad Processor Usage ---"
bad_processor = OrderProcessor.new
bad_processor.process_order(id: 1, items: [], email: "test@example.com") # Fails validation
bad_processor.process_order(id: 2, items: [{name: "Book", price: 20, quantity: 1}], email: "test@example.com") # Processes

puts "\n--- Clean Processor Usage ---"
clean_processor = CleanOrderProcessor.new
clean_processor.process_order(id: 3, items: [], email: "test@example.com") # Fails validation
clean_processor.process_order(id: 4, items: [{name: "Laptop", price: 1200, quantity: 1}, {name: "Mouse", price: 25, quantity: 2}], email: "another@example.com") # Processes

# Gemfile: Add static analysis tools
# gem 'rubocop', require: false
# gem 'brakeman', require: false
# gem 'rails_best_practices', require: false

# .rubocop.yml (example configuration snippet for enforcement)
# We enforce specific Ruby style guidelines to prevent new debt.
# frozen_string_literal: true

# Inherit from the default RuboCop configuration. Most projects begin here.
# require: rubocop-rails

AllCops:
  NewCops: enable
  TargetRubyVersion: 3.2 # Specify the Ruby version for compatibility.
  TargetRailsVersion: 7.0 # Specify the Rails version.
  Exclude:
    - 'bin/*'
    - 'db/schema.rb'
    - 'config/environments/*.rb'
    - 'node_modules/**/*'
    - 'vendor/**/*'
    - 'tmp/**/*'

# Enforce method length. Long methods are harder to read and test.
Metrics/MethodLength:
  Max: 15

# Restrict class length. Large classes often violate SRP.
Metrics/ClassLength:
  Max: 100

# Limit the number of instance variables. High counts indicate complex state.
Metrics/BlockLength:
  ExcludedMethods: ['describe', 'context', 'it', 'before', 'after', 'let', 'factory', 'feature', 'scenario'] # Common RSpec/Cucumber blocks

# Rakefile (example Rake task for basic debt reporting)
# To run: `bundle exec rake debt:report`
namespace :debt do
  desc 'Report basic technical debt metrics using RuboCop and Brakeman'
  task :report do
    puts "\n---> Running RuboCop for code style violations..."
    # We execute RuboCop in a non-interactive mode and capture output.
    system("bundle exec rubocop")

    puts "\n---> Running Brakeman for security vulnerabilities..."
    # We execute Brakeman to identify potential security holes.
    system("bundle exec brakeman -q")

    puts "\n---> Reviewing outdated dependencies (via bundle-audit if available)..."
    # Optional: If bundle-audit is installed, use it.
    # We check if bundle-audit is present before attempting to run it.
    if Gem.loaded_specs.key?('bundle-audit')
      system("bundle exec bundle-audit update && bundle exec bundle-audit check")
    else
      puts "bundle-audit not found. Install with `gem install bundle-audit` for dependency vulnerability checks."
    end

    puts "\nTechnical Debt Report Complete. Review logs for details."
  end
end

# Example: A simple, well-tested service object that's easy to refactor
# We write robust tests *before* or *during* development to ensure refactoring safety.

# app/services/user_onboarding_service.rb
class UserOnboardingService
  def initialize(user_repository: UserRepository.new, email_sender: EmailSender.new)
    @user_repository = user_repository
    @email_sender = email_sender
  end

  def onboard_user(name:, email:, password:)
    # We validate inputs explicitly to prevent invalid state.
    return nil unless name.present? && email.present? && password.present?

    user = @user_repository.create_user(name: name, email: email, password: password)
    @email_sender.send_welcome_email(user)

    user
  rescue ActiveRecord::RecordInvalid => e
    # We log specific errors to aid debugging.
    Rails.logger.error("User onboarding failed for email #{email}: #{e.message}")
    nil
  end
end

# spec/services/user_onboarding_service_spec.rb
# We use RSpec for behavior-driven development and ensure comprehensive test coverage.
require 'rails_helper'

RSpec.describe UserOnboardingService, type: :service do
  let(:user_repository_double) { instance_double(UserRepository) }
  let(:email_sender_double) { instance_double(EmailSender) }
  let(:new_user) { instance_double(User, id: 1, email: 'test@example.com', name: 'Test User') }

  before do
    # We isolate the service for testing using doubles.
    allow(UserRepository).to receive(:new).and_return(user_repository_double)
    allow(EmailSender).to receive(:new).and_return(email_sender_double)
  end

  describe '#onboard_user' do
    context 'when valid data is provided' do
      it 'creates a user and sends a welcome email' do
        expect(user_repository_double).to receive(:create_user)
          .with(name: 'John Doe', email: 'john@example.com', password: 'password123')
          .and_return(new_user)
        expect(email_sender_double).to receive(:send_welcome_email).with(new_user)

        result = described_class.new.onboard_user(name: 'John Doe', email: 'john@example.com', password: 'password123')
        expect(result).to eq(new_user)
      end
    end

    context 'when invalid data is provided' do
      it 'does not create a user or send an email' do
        expect(user_repository_double).not_to receive(:create_user)
        expect(email_sender_double).not_to receive(:send_welcome_email)

        result = described_class.new.onboard_user(name: '', email: 'john@example.com', password: 'password123')
        expect(result).to be_nil
      end
    end

    context 'when user creation fails (e.g., duplicate email)' do
      it 'logs the error and returns nil' do
        allow(user_repository_double).to receive(:create_user)
          .and_raise(ActiveRecord::RecordInvalid.new(User.new))
        expect(Rails.logger).to receive(:error).with(a_string_starting_with("User onboarding failed"))

        result = described_class.new.onboard_user(name: 'John Doe', email: 'john@example.com', password: 'password123')
        expect(result).to be_nil
      end
    end
  end
end

# Gemfile: Example of cautious dependency management
# We specify exact versions for critical gems to control upgrades, then rely on minor updates for others.

# Ensure these critical gems are pinned to specific versions to prevent unexpected breaking changes.
# We perform manual testing and review before bumping these.
# gem 'rails', '~> 7.0.8'
# gem 'pg', '~> 1.4'

# Allow minor version updates for less critical gems, but lock major versions.
# We monitor these dependencies regularly for security updates and compatibility.
# gem 'puma', '~> 6.0'
# gem 'webpacker', '~> 6.0' # Note: Webpacker is often replaced by jsbundling-rails/esbuild, etc., a prime example of evolving debt.

# Example of a new project using jsbundling-rails and esbuild for modern frontend without Webpacker debt:
# gem 'jsbundling-rails'
# # In package.json:
# # "devDependencies": {
# #   "esbuild": "^0.19.11"
# # }

# config/initializers/rubocop.rb (example for custom cops or strict adherence)
# We can define project-specific RuboCop rules to enforce architectural patterns.
# RuboCop.register_formatter('MyCustomFormatter') do |file, offenses|
#   # Custom logic for formatting or reporting
# end

# We can also dynamically load custom cops from a 'lib/rubocop/cop' directory.
# For example, a cop to detect N+1 queries in common scenarios if not caught by bullet gem.
# require_relative '../../lib/rubocop/cop/rails/no_n_plus_one_queries'

# Example for regular dependency updates through a scheduled task
# .github/workflows/dependency_review.yml (GitHub Actions example)
# We automate dependency updates and vulnerability checks.
# name: Dependency Review
# on:
#   schedule:
#     - cron: '0 0 * * 1' # Every Monday at midnight UTC
#   workflow_dispatch:
# jobs:
#   dependency-review:
#     runs-on: ubuntu-latest
#     steps:
#       - uses: actions/checkout@v4
#       - name: Set up Ruby
#         uses: ruby/setup-ruby@v1
#         with:
#           ruby-version: '3.2'
#           bundler-cache: true
#       - name: Check for outdated gems
#         run: | 
#           gem install bundler-audit
#           bundle-audit update
#           bundle-audit check
#       - name: Run `bundle outdated`
#         run: bundle outdated
#         continue-on-error: true # Allow this to pass even if there are outdated gems, just report.