# app/controllers/api/v1/profiles_controller.rb (index; BEFORE)
@profiles = Profile.preload(
  :user,
  :contact_infos,
  :skills,
  :work_experiences,
  :portfolio_links,
  :languages,
  :content_blocks,
  :skill_reviews,
  :education_items,
  :working_knowledge_items,
  :certification_items,
  :award_items,
  :project_items,
  :highlight_links,
  :security_clearance_items,
  :license_items,
  :images,
  :files,
  :location_setting,
  :salary_expectation,
  # Nested associations for models that have their own associations
  { certification_items: [:files] },
  { resume: [:files] },
  { work_experiences: :work_references },
  { education_items: [:images, :files] },
  { license_items: [:images, :files, :license_links] },
  { project_items: [:images, :files] },
  { volunteer_work_items: [:images, :files] },
  { award_items: [:files] },
  # { security_clearance_items: [:images, :files] },
  # { certification_items: [:images, :files] },
  # { working_knowledge_items: [:images, :files] }
)
.ransack(ransack_params)
.result(distinct: true)
.page(params[:page])
.per(params[:limit])

module IncludeParams
  # Whitelist to avoid arbitrary preload trees
  ALLOWED_INCLUDES = %w[
    user contact_infos skills work_experiences.work_references portfolio_links
    languages content_blocks skill_reviews education_items.images education_items.files
    working_knowledge_items certification_items.files award_items.files
    project_items.images project_items.files highlight_links security_clearance_items
    license_items.images license_items.files license_items.license_links
    images files resume.files location_setting salary_expectation volunteer_work_items.images
    volunteer_work_items.files
  ].freeze

  def parsed_includes
    raw = params[:include].to_s.split(',').map(&:strip)
    raw & ALLOWED_INCLUDES
  end

  # JSON:API-style sparse fieldsets, e.g. fields[profiles]=id,username,role
  def parsed_fields
    fields = params.fetch(:fields, {}).to_h.transform_values { |v| v.split(',').map(&:strip) }
    fields.transform_keys!(&:to_s)
  end
end

class Api::V1::ProfilesController < ApplicationController
  include IncludeParams

  # Map requested include tokens to a preload tree
  PRELOAD_MAP = {
    'user' => :user,
    'contact_infos' => :contact_infos,
    'skills' => :skills,
    'work_experiences' => { work_experiences: :work_references },
    'portfolio_links' => :portfolio_links,
    'languages' => :languages,
    'content_blocks' => :content_blocks,
    'skill_reviews' => :skill_reviews,
    'education_items.images' => { education_items: :images },
    'education_items.files'  => { education_items: :files },
    'working_knowledge_items' => :working_knowledge_items,
    'certification_items.files' => { certification_items: :files },
    'award_items.files' => { award_items: :files },
    'project_items.images' => { project_items: :images },
    'project_items.files'  => { project_items: :files },
    'highlight_links' => :highlight_links,
    'security_clearance_items' => :security_clearance_items,
    'license_items.images' => { license_items: :images },
    'license_items.files'  => { license_items: :files },
    'license_items.license_links' => { license_items: :license_links },
    'images' => :images,
    'files'  => :files,
    'resume.files' => { resume: :files },
    'location_setting' => :location_setting,
    'salary_expectation' => :salary_expectation,
    'volunteer_work_items.images' => { volunteer_work_items: :images },
    'volunteer_work_items.files'  => { volunteer_work_items: :files }
  }.freeze

  # GET /api/v1/profiles
  def index
    includes = parsed_includes
    fields   = parsed_fields
    scope    = Profile.all

    # JOINs strictly for Ransack filters/sorts.
    if params.dig(:q)&.keys&.any? { |k| k.start_with?('user_') }
      scope = scope.joins(:user)
    end
    if params.dig(:q)&.keys&.any? { |k| k.start_with?('location_setting_') }
      scope = scope.joins(:location_setting)
    end

    scope = scope.preload(preload_tree(includes)) if includes.any?

    records = scope.ransack(ransack_params).result(distinct: true)
                   .page(params[:page]).per(params[:limit])

    render json: ProfileBlueprint.render(records,
      view: view_for(includes),
      fields: fields['profiles'])
  end

  # GET /api/v1/profiles/:id
  def show
    includes = parsed_includes
    fields   = parsed_fields

    scope = Profile.preload(preload_tree(includes))
    @profile = scope.find(params[:id])

    # Strong HTTP caching: ETag + Last-Modified across key associations
    last_mod = [
      @profile.updated_at,
      @profile.skills.maximum(:updated_at),
      @profile.work_experiences.maximum(:updated_at)
    ].compact.max

    fresh_when etag: [@profile.cache_key_with_version, includes.sort],
               last_modified: last_mod,
               public: true

    render json: ProfileBlueprint.render(@profile,
      view: view_for(includes),
      fields: fields['profiles'])
  end

  private

  def preload_tree(includes)
    includes.map { |key| PRELOAD_MAP.fetch(key) }
  end

  def view_for(includes)
    if includes.any? { |i| i.start_with?('project_items') || i.start_with?('education_items') }
      :extended
    elsif includes.any?
      :standard
    else
      :compact
    end
  end

  def ransack_params
    params.fetch(:q, {})
  end
end

class ProfileBlueprint < Blueprinter::Base
  identifier :id

  view :compact do
    fields :username, :role, :location, :experience_years
    association :user, blueprint: UserBlueprint, view: :tiny
  end

  view :standard do
    include_view :compact
    association :skills, blueprint: SkillBlueprint
    association :languages, blueprint: LanguageBlueprint
  end

  view :extended do
    include_view :standard
    association :work_experiences, blueprint: WorkExperienceBlueprint, view: :with_refs
    association :education_items, blueprint: EducationItemBlueprint, view: :with_assets
    association :project_items, blueprint: ProjectItemBlueprint, view: :with_assets do |profile, options|
      max = options[:locals]&.fetch(:max_children, 25)
      profile.project_items.limit(max)
    end
    association :license_items, blueprint: LicenseItemBlueprint, view: :with_assets
    association :resume, blueprint: ResumeBlueprint, view: :with_files
  end
end

class ProjectItemBlueprint < Blueprinter::Base
  identifier :id
  fields :title, :summary, :started_on, :finished_on

  association :images, blueprint: AttachmentBlueprint
  association :files,  blueprint: AttachmentBlueprint

  # Per-record cache
  cache ->(obj, _opts) { "bp:project_item:#{obj.cache_key_with_version}" }
end

scope = Profile.all

joins_needed = []
joins_needed << :user if params.dig(:q)&.keys&.any? { |k| k.start_with?('user_') }
joins_needed << :location_setting if params.dig(:q)&.keys&.any? { |k| k.start_with?('location_setting_') }
scope = scope.joins(*joins_needed) if joins_needed.any?

scope = scope.preload(preload_tree(parsed_includes))
records = scope.ransack(ransack_params).result(distinct: true)

config.active_record.async_query_executor = :global_thread_pool
config.active_record.global_executor_concurrency = 4 # tune per env

@profile = Profile.preload(preload_tree(parsed_includes)).load_async.find(params[:id])

# app/controllers/api/v1/profiles_controller.rb (show)
render json: ProfileBlueprint.render(@profile, view: :extended, locals: { max_children: 25 })

class Api::V1::ProfileAssociationsController < ApplicationController
  include IncludeParams

  def show
    profile = Profile.find(params[:id])
    includes = parsed_includes
    raise ActionController::BadRequest, "include= required" if includes.blank?

    # Preload requested bits only
    Profile.where(id: profile.id).preload(preload_tree(includes)).load

    render json: {
      id: profile.id,
      include: includes,
      data: ProfileBlueprint.render(profile, view: :extended, fields: params.dig(:fields, 'profiles'))
    }
  end

  private

  def preload_tree(includes)
    includes.map { |key| Api::V1::ProfilesController::PRELOAD_MAP.fetch(key) }
  end
end

class Profile < ApplicationRecord
  has_many :skills, inverse_of: :profile, dependent: :destroy
  has_many :project_items, inverse_of: :profile, dependent: :destroy
  # If you use counters a lot:
  # has_many :work_experiences, inverse_of: :profile, dependent: :destroy, counter_cache: true
end

# app/models/profile.rb
def self.ransackable_associations(_ = nil)
  %w[user location_setting]
end

def self.ransackable_attributes(_ = nil)
  %w[username role location experience_years]
end

it 'stays under 12 queries for compact show' do
  expect {
    get "/api/v1/profiles/#{profile.id}"
  }.to make_database_queries(count: <= 12) # adapt matcher/threshold
end

Profile.preload(
  :user,
  :contact_infos,
  :skills,
  :work_experiences,
  :portfolio_links,
  :languages,
  :content_blocks,
  :skill_reviews,
  :education_items,
  :working_knowledge_items,
  :certification_items,
  :award_items,
  :project_items,
  :highlight_links,
  :security_clearance_items,
  :license_items,
  :images,
  :files,
  :location_setting,
  :salary_expectation,
  { certification_items: [:files] },
  { resume: [:files] },
  { work_experiences: :work_references },
  { education_items: [:images, :files] },
  { license_items: [:images, :files, :license_links] },
  { project_items: [:images, :files] },
  { volunteer_work_items: [:images, :files] },
  { award_items: [:files] }
)