LHR Implementation Plan - Complete & Ready

cd backend
rails generate migration CreateClinicalImpressions
rails generate migration CreateMedicationRequests
rails generate migration CreateServiceRequests  
rails generate migration CreatePatientProblems
rails generate migration CreateCarePlans
rails generate migration CreateClinicalObservations
rails generate migration CreateDiagnosticReports
rails generate migration CreateCarePlanProblems
rails generate migration EnhancePrescriptionsStructuredDiagnosis
rails generate migration RenameCareplansTable

class CreateClinicalImpressions < ActiveRecord::Migration[7.1]
  def change
    create_table :clinical_impressions do |t|
      t.references :clinic, null: false, foreign_key: true, index: true
      t.references :patient, null: false, foreign_key: true, index: true
      t.references :doctor, null: false, foreign_key: true, index: true
      t.references :encounter, foreign_key: { to_table: :appointments }, null: true, index: true
      t.references :prescription, null: false, foreign_key: true, index: true
      
      # FHIR ClinicalImpression fields
      t.string :status, default: 'completed'
      t.string :subject_reference
      t.timestamp :assessment_date
      
      # Clinical assessment
      t.text :summary
      t.jsonb :finding_codes, default: []
      t.jsonb :finding_display, default: []
      t.text :clinical_notes
      
      # Outcome and recommendations
      t.text :prognostic_reference
      t.text :plan_reference
      
      # Links to other resources
      t.bigint :supports_prescriptions, array: true, default: []
      
      # Document generation
      t.boolean :document_generated, default: false
      t.text :document_url
      t.jsonb :metadata, default: {}
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_index :clinical_impressions, [:clinic_id, :patient_id]
    add_index :clinical_impressions, [:patient_id, :status]
    add_index :clinical_impressions, :supports_prescriptions, using: :gin
  end
end

class CreateMedicationRequests < ActiveRecord::Migration[7.1]
  def change
    create_table :medication_requests do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      t.bigint :encounter_id, null: true  # nullable - prescriptions may not belong to appointment
      t.bigint :prescription_id, null: false
      
      # FHIR MedicationRequest fields
      t.string :status, default: 'active'
      t.string :intent, default: 'order'
      t.string :medication_name, null: false
      t.string :medication_type
      t.string :strength
      t.string :form
      
      # Dosage
      t.text :dosage_instruction
      t.string :frequency
      t.integer :quantity_value
      t.string :quantity_unit
      t.integer :duration_value
      t.string :duration_unit
      t.text :instructions
      t.boolean :as_needed, default: false
      
      # Document generation
      t.boolean :document_generated, default: false
      t.text :document_url
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :medication_requests, :clinics
    add_foreign_key :medication_requests, :patients
    add_foreign_key :medication_requests, :doctors
    add_foreign_key :medication_requests, :appointments, column: :encounter_id
    add_foreign_key :medication_requests, :prescriptions, column: :prescription_id
    
    add_index :medication_requests, [:clinic_id, :patient_id]
    add_index :medication_requests, [:patient_id, :status]
    add_index :medication_requests, :encounter_id
    add_index :medication_requests, :prescription_id
  end
end

class CreateServiceRequests < ActiveRecord::Migration[7.1]
  def change
    create_table :service_requests do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      t.bigint :encounter_id, null: true  # nullable - prescriptions may not belong to appointment
      t.bigint :prescription_id, null: false
      
      # FHIR ServiceRequest fields
      t.string :status, default: 'active'
      t.string :intent, default: 'order'
      t.string :service_type
      t.string :service_name, null: false
      t.string :service_code
      t.text :instructions
      
      # Document generation
      t.boolean :document_generated, default: false
      t.text :document_url
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :service_requests, :clinics
    add_foreign_key :service_requests, :patients
    add_foreign_key :service_requests, :doctors
    add_foreign_key :service_requests, :appointments, column: :encounter_id
    add_foreign_key :service_requests, :prescriptions, column: :prescription_id
    
    add_index :service_requests, [:clinic_id, :patient_id]
    add_index :service_requests, [:patient_id, :status]
    add_index :service_requests, :encounter_id
    add_index :service_requests, :prescription_id
  end
end

class CreatePatientProblems < ActiveRecord::Migration[7.1]
  def change
    create_table :patient_problems do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      
      # Problem identification
      t.string :problem_code # ICD-10 code
      t.string :problem_name, null: false
      t.string :problem_category
      t.string :severity, default: 'medium' # low, medium, high, critical
      
      # Timeline
      t.date :onset_date
      t.date :resolved_date
      t.string :status, default: 'active' # active, resolved, chronic, improving
      
      # Clinical context
      t.bigint :first_encounter_id # first appointment where identified
      t.bigint :last_encounter_id  # last appointment where addressed
      
      # Links to source data
      t.bigint :source_prescription_id # prescription that identified this problem
      t.string :source_complaint_text  # original complaint text
      
      # Notes
      t.text :clinical_notes
      t.jsonb :metadata, default: {}
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :patient_problems, :clinics
    add_foreign_key :patient_problems, :patients
    add_foreign_key :patient_problems, :doctors
    add_foreign_key :patient_problems, :appointments, column: :first_encounter_id
    add_foreign_key :patient_problems, :appointments, column: :last_encounter_id
    add_foreign_key :patient_problems, :prescriptions, column: :source_prescription_id
    
    add_index :patient_problems, [:clinic_id, :patient_id]
    add_index :patient_problems, [:patient_id, :status]
    add_index :patient_problems, :problem_code
    add_index :patient_problems, [:source_prescription_id]
  end
end

class CreateClinicalObservations < ActiveRecord::Migration[7.1]
  def change
    create_table :clinical_observations do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      t.bigint :encounter_id, null: true
      t.bigint :prescription_id, null: true
      
      # FHIR Observation fields
      t.string :status, default: 'final'
      t.string :category # 'vital-signs', 'laboratory', 'exam', 'survey'
      t.string :code # LOINC code
      t.string :display_name, null: false
      
      # Value (polymorphic to support different types)
      t.string :value_type # 'quantity', 'string', 'boolean', 'range'
      t.decimal :value_quantity, precision: 10, scale: 3
      t.string :value_unit
      t.string :value_string
      t.boolean :value_boolean
      t.decimal :range_low, precision: 10, scale: 3
      t.decimal :range_high, precision: 10, scale: 3
      
      # Reference ranges
      t.jsonb :reference_range, default: {}
      t.string :interpretation # 'normal', 'abnormal', 'high', 'low', 'critical'
      
      # Clinical context
      t.text :notes
      t.jsonb :metadata, default: {}
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :clinical_observations, :clinics
    add_foreign_key :clinical_observations, :patients
    add_foreign_key :clinical_observations, :doctors
    add_foreign_key :clinical_observations, :appointments, column: :encounter_id
    add_foreign_key :clinical_observations, :prescriptions, column: :prescription_id
    
    add_index :clinical_observations, [:clinic_id, :patient_id]
    add_index :clinical_observations, [:patient_id, :category]
    add_index :clinical_observations, [:encounter_id]
    add_index :clinical_observations, [:code]
    add_index :clinical_observations, [:value_type]
  end
end

class CreateDiagnosticReports < ActiveRecord::Migration[7.1]
  def change
    create_table :diagnostic_reports do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      t.bigint :encounter_id, null: true
      t.bigint :prescription_id, null: true
      
      # FHIR DiagnosticReport fields
      t.string :status, default: 'final'
      t.string :category # 'lab', 'radiology', 'cardiology', 'pathology', 'general'
      t.string :code # LOINC code for report type
      t.string :display_name, null: false
      
      # Report content
      t.text :conclusion
      t.text :conclusion_code # ICD-10 codes
      t.jsonb :coded_diagnosis, default: [] # Array of diagnosis codes
      
      # Links to observations
      t.bigint :clinical_observations, array: true, default: []
      
      # Document references
      t.text :document_url
      t.string :document_type # 'pdf', 'image', 'text'
      
      # Clinical significance
      t.string :clinical_significance # 'normal', 'abnormal', 'critical'
      t.text :clinical_notes
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :diagnostic_reports, :clinics
    add_foreign_key :diagnostic_reports, :patients
    add_foreign_key :diagnostic_reports, :doctors
    add_foreign_key :diagnostic_reports, :appointments, column: :encounter_id
    add_foreign_key :diagnostic_reports, :prescriptions, column: :prescription_id
    
    add_index :diagnostic_reports, [:clinic_id, :patient_id]
    add_index :diagnostic_reports, [:patient_id, :category]
    add_index :diagnostic_reports, [:encounter_id]
    add_index :diagnostic_reports, [:status]
    add_index "diagnostic_reports", "clinical_observations", using: :gin
  end
end

class CreateCarePlans < ActiveRecord::Migration[7.1]
  def change
    create_table :care_plans do |t|
      t.bigint :clinic_id, null: false
      t.bigint :patient_id, null: false
      t.bigint :doctor_id, null: false
      
      # FHIR CarePlan fields
      t.string :status, default: 'active'
      t.string :intent, default: 'plan'
      t.string :title
      t.text :description
      
      # Timeline
      t.date :period_start
      t.date :period_end
      
      # Care coordination
      t.jsonb :goals, default: {}
      t.jsonb :activities, default: {}
      t.jsonb :care_team, default: []
      
      # Problem references (array of patient_problem ids)
      t.bigint :addresses_problems, array: true, default: []
      
      # Document generation
      t.boolean :document_generated, default: false
      t.text :document_url
      
      t.boolean :deleted, default: false
      t.timestamps
    end
    
    add_foreign_key :care_plans, :clinics
    add_foreign_key :care_plans, :patients
    add_foreign_key :care_plans, :doctors
    
    add_index :care_plans, [:clinic_id, :patient_id]
    add_index :care_plans, [:patient_id, :status]
    add_index "care_plans", "addresses_problems", using: :gin
  end
end

class CreateCarePlanProblems < ActiveRecord::Migration[7.1]
  def change
    create_table :care_plan_problems do |t|
      t.bigint :care_plan_id, null: false
      t.bigint :patient_problem_id, null: false
      
      t.timestamps
    end
    
    add_foreign_key :care_plan_problems, :care_plans
    add_foreign_key :care_plan_problems, :patient_problems
    add_index :care_plan_problems, [:care_plan_id, :patient_problem_id], unique: true, name: 'idx_care_plan_problems_unique'
  end
end

class EnhancePrescriptionsStructuredDiagnosis < ActiveRecord::Migration[7.1]
  def change
    # Enhance prescriptions with structured diagnosis
    add_column :prescriptions, :diagnosis_codes, :string, array: true, default: []
    add_column :prescriptions, :diagnosis_certainty, :string, default: 'provisional'
    add_column :prescriptions, :chief_complaint_structured, :jsonb, default: {}
    add_column :prescriptions, :clinical_impression, :text
    
    # Add indexes for new fields
    add_index :prescriptions, :diagnosis_codes, using: :gin
    add_index :prescriptions, :diagnosis_certainty
  end
end

class RenameCareplansTable < ActiveRecord::Migration[7.1]
  def change
    # Rename main table
    rename_table :careplans, :prescriptions
    
    # Update foreign key columns in related tables
    rename_column :careplan_medicines, :careplan_id, :prescription_id
    rename_column :careplan_test_lists, :careplan_id, :prescription_id
    rename_column :careplan_complaints, :careplan_id, :prescription_id
    rename_column :careplan_procedures, :careplan_id, :prescription_id
    rename_column :careplan_diets, :careplan_id, :prescription_id
    rename_column :careplan_advices, :careplan_id, :prescription_id
    rename_column :patient_medicines, :careplan_id, :prescription_id
    
    # Update polymorphic references
    execute "UPDATE patient_history_logs SET trackable_type = 'Prescription' WHERE trackable_type = 'Careplan'"
    execute "UPDATE medical_record_tags SET taggable_type = 'Prescription' WHERE taggable_type = 'Careplan'"
    execute "UPDATE pharmacy_orders SET event_type = 'Prescription' WHERE event_type = 'Careplan'"
    execute "UPDATE lab_orders SET event_type = 'Prescription' WHERE event_type = 'Careplan'"
    
    # Rename related tables
    rename_table :careplan_medicines, :prescription_medicines
    rename_table :careplan_test_lists, :prescription_test_lists
    rename_table :careplan_complaints, :prescription_complaints
    rename_table :careplan_procedures, :prescription_procedures
    rename_table :careplan_diets, :prescription_diets
    rename_table :careplan_advices, :prescription_advices
  end
end

# parts/patient/models/clinical_impression.rb
class ClinicalImpression < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :encounter, class_name: 'Appointment', optional: true
  belongs_to :prescription
  
  # Validations
  validates :status, inclusion: { in: %w[in-progress completed entered-in-error] }
  validates :assessment_date, presence: true
  
  # Scopes
  scope :completed, -> { where(status: 'completed') }
  scope :for_patient, ->(patient_id) { where(patient_id: patient_id) }
  scope :for_clinic, ->(clinic_id) { where(clinic_id: clinic_id) }
  scope :recent, -> { order(assessment_date: :desc) }
  
  # Callbacks
  after_create :generate_document_async, if: -> { prescription.is_final? }
  
  private
  
  def generate_document_async
    ClinicalImpressions::GenerateDocumentJob.perform_later(self.id)
  end
end

# parts/patient/models/medication_request.rb
class MedicationRequest < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :encounter, class_name: 'Appointment', optional: true
  belongs_to :prescription
  
  # Validations
  validates :medication_name, presence: true
  validates :status, inclusion: { in: %w[active on-hold cancelled completed] }
  validates :intent, inclusion: { in: %w[proposal plan order] }
  
  # Scopes
  scope :active, -> { where(status: 'active') }
  scope :for_patient, ->(patient_id) { where(patient_id: patient_id) }
  scope :for_clinic, ->(clinic_id) { where(clinic_id: clinic_id) }
  
  # Callbacks - Only generate documents for finalized prescriptions
  after_create :generate_document_async, if: -> { prescription.is_final? }
  after_update :update_patient_medicine_if_needed
  
  private
  
  def generate_document_async
    MedicationRequests::GenerateDocumentJob.perform_later(self.id)
  end
  
  def update_patient_medicine_if_needed
    return unless status_changed? && status == 'completed'
    
    patient_medicine = PatientMedicine.find_by(
      patient_id: patient_id,
      prescription_id: prescription_id,
      medicine_name: medication_name
    )
    patient_medicine&.update!(active: false, completed_at: Time.current)
  end
end

# parts/patient/models/service_request.rb  
class ServiceRequest < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :encounter, class_name: 'Appointment', optional: true
  belongs_to :prescription
  
  # Validations
  validates :service_name, presence: true
  validates :service_type, inclusion: { in: %w[lab_test imaging procedure] }
  validates :status, inclusion: { in: %w[active on-hold cancelled completed] }
  
  # Scopes
  scope :active, -> { where(status: 'active') }
  scope :lab_tests, -> { where(service_type: 'lab_test') }
  scope :for_clinic, ->(clinic_id) { where(clinic_id: clinic_id) }
  
  # Callbacks - Only generate documents for finalized prescriptions
  after_create :generate_document_async, if: -> { prescription.is_final? }
  
  private
  
  def generate_document_async
    ServiceRequests::GenerateDocumentJob.perform_later(self.id)
  end
end

# parts/patient/models/patient_problem.rb
class PatientProblem < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :first_encounter, class_name: 'Appointment', optional: true
  belongs_to :last_encounter, class_name: 'Appointment', optional: true
  belongs_to :source_prescription, class_name: 'Prescription', optional: true
  
  # Many-to-many with care plans
  has_many :care_plan_problems, dependent: :destroy
  has_many :care_plans, through: :care_plan_problems
  
  # Validations
  validates :problem_name, presence: true
  validates :status, inclusion: { in: %w[active resolved chronic improving] }
  validates :severity, inclusion: { in: %w[low medium high critical] }
  
  # Scopes
  scope :active, -> { where(status: 'active') }
  scope :chronic, -> { where(status: 'chronic') }
  scope :for_clinic, ->(clinic_id) { where(clinic_id: clinic_id) }
  scope :for_patient, ->(patient_id) { where(patient_id: patient_id) }
  
  # Methods for frontend integration
  def linked_medications
    return [] unless source_prescription
    source_prescription.medication_requests.pluck(:id).map(&:to_s)
  end
  
  def linked_encounters
    encounters = []
    encounters << first_encounter_id.to_s if first_encounter_id
    encounters << last_encounter_id.to_s if last_encounter_id && last_encounter_id != first_encounter_id
    encounters.compact
  end
  
  def icd_code
    problem_code
  end
end

# parts/patient/models/clinical_observation.rb
class ClinicalObservation < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :encounter, class_name: 'Appointment', optional: true
  belongs_to :prescription, optional: true
  
  # Validations
  validates :display_name, presence: true
  validates :category, inclusion: { in: %w[vital-signs laboratory exam survey] }
  validates :value_type, inclusion: { in: %w[quantity string boolean range] }
  validates :status, inclusion: { in: %w[registered preliminary final amended cancelled] }
  
  # Scopes
  scope :vital_signs, -> { where(category: 'vital-signs') }
  scope :lab_results, -> { where(category: 'laboratory') }
  scope :exam_findings, -> { where(category: 'exam') }
  scope :for_encounter, ->(encounter_id) { where(encounter_id: encounter_id) }
  
  # Methods
  def formatted_value
    case value_type
    when 'quantity'
      "#{value_quantity} #{value_unit}".strip
    when 'string'
      value_string
    when 'boolean'
      value_boolean ? 'Yes' : 'No'
    when 'range'
      "#{range_low} - #{range_high} #{value_unit}".strip
    else
      'Unknown'
    end
  end
  
  def is_abnormal?
    interpretation.in?(['abnormal', 'high', 'low', 'critical'])
  end
end

# parts/patient/models/diagnostic_report.rb
class DiagnosticReport < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor
  belongs_to :encounter, class_name: 'Appointment', optional: true
  belongs_to :prescription, optional: true
  
  # Validations
  validates :display_name, presence: true
  validates :category, inclusion: { in: %w[lab radiology cardiology pathology general] }
  validates :status, inclusion: { in: %w[registered partial preliminary final amended cancelled] }
  
  # Scopes
  scope :final_reports, -> { where(status: 'final') }
  scope :by_category, ->(category) { where(category: category) }
  scope :for_encounter, ->(encounter_id) { where(encounter_id: encounter_id) }
  
  # Methods
  def is_abnormal?
    clinical_significance.in?(['abnormal', 'critical'])
  end
  
  def diagnosis_list
    coded_diagnosis.is_a?(Array) ? coded_diagnosis : []
  end
end

# parts/patient/models/care_plan.rb
class CarePlan < ApplicationRecord
  include PublicActivity::Common
  include PatientHistoryActivity
  
  # Associations
  belongs_to :clinic
  belongs_to :patient
  belongs_to :doctor # Primary care coordinator
  
  # Many-to-many with patient problems
  has_many :care_plan_problems, dependent: :destroy
  has_many :patient_problems, through: :care_plan_problems
  
  # Validations
  validates :status, inclusion: { in: %w[draft active on-hold revoked completed] }
  validates :intent, inclusion: { in: %w[proposal plan order option] }
  
  # Scopes
  scope :active, -> { where(status: 'active') }
  scope :for_clinic, ->(clinic_id) { where(clinic_id: clinic_id) }
  scope :for_patient, ->(patient_id) { where(patient_id: patient_id) }
  
  # JSON field accessors
  def goal_list
    goals.is_a?(Hash) ? goals.values : []
  end
  
  def activity_list
    activities.is_a?(Hash) ? activities.values : []
  end
  
  def care_team_members
    care_team.is_a?(Array) ? care_team : []
  end
  
  # Problem management
  def add_problem(patient_problem)
    return if patient_problems.include?(patient_problem)
    
    patient_problems << patient_problem
    update_addresses_problems_array
  end
  
  def remove_problem(patient_problem)
    patient_problems.delete(patient_problem)
    update_addresses_problems_array
  end
  
  private
  
  def update_addresses_problems_array
    update!(addresses_problems: patient_problems.pluck(:id))
  end
end

# parts/patient/models/care_plan_problem.rb
class CarePlanProblem < ApplicationRecord
  belongs_to :care_plan
  belongs_to :patient_problem
  
  validates :care_plan_id, uniqueness: { scope: :patient_problem_id }
end

# parts/doctor/models/prescription.rb (renamed from careplan.rb)
class Prescription < ApplicationRecord
  # Existing concerns
  include PublicActivity::Common
  include AbdmCareContextFunctions
  include AbdmFhirFunctions
  include PatientHistoryActivity
  include IpEncounterActivityLog
  
  # Associations - Updated names
  has_many :prescription_medicines, dependent: :destroy
  has_many :prescription_test_lists, dependent: :destroy
  has_many :prescription_complaints, dependent: :destroy
  has_many :prescription_procedures, dependent: :destroy
  has_many :prescription_diets, dependent: :destroy
  has_many :prescription_advices, dependent: :destroy
  
  # New FHIR associations
  has_many :clinical_impressions, dependent: :destroy
  has_many :medication_requests, dependent: :destroy
  has_many :service_requests, dependent: :destroy
  has_many :clinical_observations, dependent: :destroy
  has_many :diagnostic_reports, dependent: :destroy
  has_many :patient_problems, foreign_key: :source_prescription_id, dependent: :nullify
  
  # Existing associations
  has_many :patient_medicines, foreign_key: :prescription_id, dependent: :destroy
  belongs_to :doctor
  belongs_to :event, polymorphic: true, optional: true
  belongs_to :patient, optional: true
  belongs_to :clinic_patient, optional: true
  belongs_to :clinic, optional: true
  
  # Existing scopes
  scope :order_by_latest, -> { order('created_at desc') }
  scope :final, -> { where(is_final: true) }
  
  # Callbacks - ONLY trigger FHIR resources when finalized
  after_update :create_fhir_resources_if_finalized
  after_create :update_create_ts
  
  # Existing methods
  def unread_lab_results?
    lab_orders.where(read_by_clinic: false).count.positive?
  end
  
  def clinic_doc
    return if clinic_id.blank? && doctor_id.blank?
    ClinicDoctor.find_by(clinic_id: clinic_id, doctor_id: doctor_id)
  end
  
  def update_create_ts
    update!(create_ts: Time.now)
  end
  
  private
  
  def create_fhir_resources_if_finalized
    return unless is_final? && is_final_changed?
    
    Prescriptions::CreateFhirResourcesJob.perform_later(self.id)
  end
end

# parts/patient/interactors/patients/get_longitudinal_health_record.rb
class Patients::GetLongitudinalHealthRecord < BaseInteractor
  def call
    validate_access
    gather_patient_info
    build_encounters_history
    aggregate_current_medications
    aggregate_problem_list
    build_vitals_trends
    build_medication_history
    build_lab_results
    calculate_summary_metrics
    build_response
  end
  
  private
  
  def validate_access
    context.clinic_patient = ClinicPatient.find_by!(
      clinic_id: current_user.clinic_id,
      patient_id: context.patient_id
    )
    context.patient = context.clinic_patient.patient
    authorize(context.patient, :show?)
  end
  
  def gather_patient_info
    patient = context.patient
    context.patient_info = {
      id: patient.id.to_s,
      name: "#{patient.first_name} #{patient.last_name}".strip,
      age: patient.age || calculate_age_from_dob(patient.date_of_birth),
      gender: patient.gender&.capitalize || 'Unknown',
      phone: patient.phone_number,
      email: patient.email,
      medicalId: context.clinic_patient.patient_code || "MR-#{patient.id}",
      allergies: patient.allergies || [],
      bloodGroup: patient.blood_group,
      chronicConditions: extract_chronic_conditions(patient)
    }
  end
  
  def build_encounters_history
    appointments = Appointment.includes(
      :doctor, :clinic_doctor, 
      prescription: [:prescription_complaints, :prescription_medicines, :prescription_test_lists]
    ).where(clinic_patient_id: context.clinic_patient.id)
     .order(appointment_date: :desc)
     .limit(50)
    
    context.encounters = appointments.map { |appt| format_encounter(appt) }
  end
  
  def aggregate_current_medications
    current_meds = PatientMedicine.includes(:prescription => :doctor)
                                 .where(patient_id: context.patient_id, active: true)
    
    context.current_medications = current_meds.map { |med| format_current_medication(med) }
  end
  
  def aggregate_problem_list
    problems = PatientProblem.includes(:first_encounter, :last_encounter)
                            .where(clinic_id: current_user.clinic_id, patient_id: context.patient_id)
                            .order(:onset_date)
    
    context.problem_list = problems.map { |problem| format_patient_problem(problem) }
  end
  
  def build_vitals_trends
    context.vitals_trends = Patients::BuildVitalsTrends.call(
      clinic_patient_id: context.clinic_patient.id
    ).vitals_trends || []
  end
  
  def build_medication_history
    context.medication_history = Patients::BuildMedicationHistory.call(
      clinic_id: current_user.clinic_id,
      patient_id: context.patient_id
    ).medication_history || []
  end
  
  def build_lab_results
    context.lab_results = Patients::BuildLabResults.call(
      clinic_id: current_user.clinic_id,
      patient_id: context.patient_id
    ).lab_results || []
  end
  
  def calculate_summary_metrics
    context.last_visit_date = context.encounters.first&.dig(:date)
    context.next_appointment_date = get_next_appointment_date
    context.active_problems_count = context.problem_list.count { |p| p[:status].in?(['active', 'chronic']) }
    context.current_medications_count = context.current_medications.count
    context.total_encounters = context.encounters.count
  end
  
  def build_response
    context.longitudinal_data = {
      patientId: context.patient_id.to_s,
      patientInfo: context.patient_info,
      encounters: context.encounters,
      currentMedications: context.current_medications,
      problemList: context.problem_list,
      vitalsTrends: context.vitals_trends,
      medicationHistory: context.medication_history,
      labResults: context.lab_results,
      lastVisitDate: context.last_visit_date,
      nextAppointmentDate: context.next_appointment_date,
      activeProblemsCount: context.active_problems_count,
      currentMedicationsCount: context.current_medications_count,
      totalEncounters: context.total_encounters
    }
  end
  
  # Formatting methods to match frontend expectations
  def format_encounter(appointment)
    prescription = appointment.prescription
    doctor_name = "Dr. #{appointment.doctor.first_name} #{appointment.doctor.last_name}"
    
    {
      id: appointment.id.to_s,
      date: appointment.appointment_date.in_time_zone,
      type: map_appointment_type(appointment.appointment_type),
      provider: doctor_name,
      chiefComplaint: extract_chief_complaint(appointment, prescription),
      diagnosis: prescription&.diagnosis || [],
      status: appointment.status == 'completed' ? 'completed' : 'in-progress',
      hasNotes: prescription&.notes.present? || appointment.notes.present?,
      hasPrescriptions: prescription&.prescription_medicines&.any?,
      hasLabOrders: prescription&.prescription_test_lists&.any?,
      vitals: extract_vitals_from_appointment(appointment),
      medications: extract_medications_from_prescription(prescription),
      problems: extract_problems_from_prescription(prescription),
      labResults: extract_lab_results_from_prescription(prescription)
    }
  end
  
  def format_current_medication(patient_medicine)
    prescription = patient_medicine.prescription
    doctor_name = "Dr. #{prescription.doctor.first_name} #{prescription.doctor.last_name}"
    
    {
      id: patient_medicine.id.to_s,
      drugName: patient_medicine.medicine_name,
      genericName: patient_medicine.medicine_name,
      dosage: patient_medicine.dosage,
      frequency: patient_medicine.frequency,
      duration: patient_medicine.duration || 'Ongoing',
      route: 'PO',
      instructions: patient_medicine.instructions,
      startDate: patient_medicine.created_at,
      lastModified: patient_medicine.updated_at,
      prescribedBy: doctor_name,
      isControlled: false,
      interactions: [],
      prescriptionStatus: patient_medicine.active? ? 'active' : 'completed',
      adherenceRate: calculate_adherence_rate(patient_medicine),
      refillsRemaining: patient_medicine.refills_remaining,
      nextRefillDate: calculate_next_refill_date(patient_medicine)
    }
  end
  
  def format_patient_problem(problem)
    {
      id: problem.id.to_s,
      name: problem.problem_name,
      icdCode: problem.problem_code,
      status: problem.status,
      severity: problem.severity,
      onsetDate: problem.onset_date,
      resolvedDate: problem.resolved_date,
      lastReviewDate: problem.last_encounter&.appointment_date || problem.updated_at.to_date,
      linkedMedications: problem.linked_medications,
      linkedEncounters: problem.linked_encounters,
      notes: problem.clinical_notes
    }
  end
end

# parts/doctor/jobs/prescriptions/create_fhir_resources_job.rb
class Prescriptions::CreateFhirResourcesJob < ApplicationJob
  queue_as :default
  
  def perform(prescription_id)
    prescription = Prescription.find(prescription_id)
    
    # Only proceed if prescription is finalized
    return unless prescription.is_final?
    
    ActiveRecord::Base.transaction do
      create_clinical_impression(prescription)
      create_medication_requests(prescription)
      create_service_requests(prescription)
      create_clinical_observations(prescription)
      create_diagnostic_reports(prescription)
      update_patient_problems(prescription)
      update_care_plan(prescription)
    end
  rescue StandardError => e
    Rails.logger.error "Failed to create FHIR resources for prescription #{prescription_id}: #{e.message}"
    raise e
  end
  
  private
  
  def create_clinical_impression(prescription)
    return if prescription.diagnosis.blank? && prescription.observations.blank?
    
    ClinicalImpression.find_or_create_by(
      prescription_id: prescription.id
    ) do |impression|
      impression.assign_attributes(
        clinic_id: prescription.clinic_id,
        patient_id: prescription.patient_id,
        doctor_id: prescription.doctor_id,
        encounter_id: prescription.event_id,
        assessment_date: prescription.created_at,
        summary: build_clinical_summary(prescription),
        finding_codes: extract_diagnosis_codes(prescription.diagnosis),
        finding_display: prescription.diagnosis || [],
        clinical_notes: prescription.observations,
        status: 'completed'
      )
    end
  end
  
  def create_medication_requests(prescription)
    prescription.prescription_medicines.each do |medicine|
      MedicationRequest.find_or_create_by(
        prescription_id: prescription.id,
        medication_name: medicine.medicine_name
      ) do |med_req|
        med_req.assign_attributes(
          clinic_id: prescription.clinic_id,
          patient_id: prescription.patient_id,
          doctor_id: prescription.doctor_id,
          encounter_id: prescription.event_id,
          medication_type: medicine.medicine_type,
          dosage_instruction: "#{medicine.dosage} #{medicine.frequency}",
          frequency: medicine.frequency,
          instructions: medicine.instructions,
          status: 'active'
        )
      end
    end
  end
  
  def create_service_requests(prescription)
    prescription.prescription_test_lists.each do |test_list|
      test_list.prescription_tests.each do |test|
        ServiceRequest.find_or_create_by(
          prescription_id: prescription.id,
          service_name: test.test_name
        ) do |svc_req|
          svc_req.assign_attributes(
            clinic_id: prescription.clinic_id,
            patient_id: prescription.patient_id,
            doctor_id: prescription.doctor_id,
            encounter_id: prescription.event_id,
            service_type: 'lab_test',
            service_code: test.test_code,
            instructions: test.instructions,
            status: 'active'
          )
        end
      end
    end
  end
  
  def create_clinical_observations(prescription)
    # From prescription observations
    if prescription.observations.present?
      ClinicalObservation.find_or_create_by(
        prescription_id: prescription.id,
        display_name: 'Clinical Observations'
      ) do |obs|
        obs.assign_attributes(
          clinic_id: prescription.clinic_id,
          patient_id: prescription.patient_id,
          doctor_id: prescription.doctor_id,
          encounter_id: prescription.event_id,
          category: 'exam',
          code: 'CLINICAL-OBS',
          value_type: 'string',
          value_string: prescription.observations,
          interpretation: 'normal'
        )
      end
    end
    
    # From encounter vitals if available
    if prescription.event_type == 'Appointment' && prescription.event.vitals.present?
      create_vitals_observations(prescription)
    end
  end
  
  def create_diagnostic_reports(prescription)
    return unless prescription.diagnosis.present?
    
    DiagnosticReport.find_or_create_by(
      prescription_id: prescription.id,
      display_name: 'Clinical Assessment'
    ) do |report|
      report.assign_attributes(
        clinic_id: prescription.clinic_id,
        patient_id: prescription.patient_id,
        doctor_id: prescription.doctor_id,
        encounter_id: prescription.event_id,
        category: 'general',
        code: 'CLINICAL-ASSESSMENT',
        conclusion: prescription.diagnosis.join(', '),
        coded_diagnosis: prescription.diagnosis_codes || [],
        clinical_significance: determine_clinical_significance(prescription.diagnosis),
        clinical_notes: prescription.notes,
        status: 'final'
      )
    end
  end
  
  def update_patient_problems(prescription)
    prescription.diagnosis.each_with_index do |diagnosis, index|
      problem_code = prescription.diagnosis_codes&.at(index)
      complaint_text = prescription.prescription_complaints.pluck(:name).join(', ')
      
      problem = PatientProblem.find_or_initialize_by(
        clinic_id: prescription.clinic_id,
        patient_id: prescription.patient_id,
        problem_name: diagnosis
      )
      
      if problem.new_record?
        problem.assign_attributes(
          doctor_id: prescription.doctor_id,
          problem_code: problem_code,
          problem_category: categorize_diagnosis(diagnosis),
          severity: determine_severity(diagnosis),
          status: determine_status(diagnosis),
          onset_date: prescription.prescription_date || prescription.created_at.to_date,
          first_encounter_id: prescription.event_id,
          last_encounter_id: prescription.event_id,
          source_prescription_id: prescription.id,
          source_complaint_text: complaint_text,
          clinical_notes: "Identified from prescription diagnosis"
        )
      else
        problem.update!(
          last_encounter_id: prescription.event_id,
          clinical_notes: "#{problem.clinical_notes}\\n\\nUpdated: #{prescription.created_at.strftime('%Y-%m-%d')}"
        )
      end
      
      problem.save!
    end
  end
  
  def build_clinical_summary(prescription)
    summary_parts = []
    
    if prescription.prescription_complaints.any?
      complaints = prescription.prescription_complaints.pluck(:name).join(', ')
      summary_parts << "Chief Complaints: #{complaints}"
    end
    
    if prescription.observations.present?
      summary_parts << "Clinical Findings: #{prescription.observations}"
    end
    
    if prescription.diagnosis.any?
      summary_parts << "Assessment: #{prescription.diagnosis.join(', ')}"
    end
    
    summary_parts.join("\\n\\n")
  end
  
  def extract_diagnosis_codes(diagnoses)
    return [] unless diagnoses.present?
    
    # Extract ICD-10 codes if present, otherwise map common diagnoses
    diagnoses.map do |diagnosis|
      # Check if already contains ICD code pattern
      if diagnosis.match?(/[A-Z]\d{2}\.?\d*/)
        diagnosis.match(/([A-Z]\d{2}\.?\d*)/)[1]
      else
        # Map common diagnoses to ICD-10 codes
        map_diagnosis_to_icd10(diagnosis)
      end
    end.compact
  end
  
  def map_diagnosis_to_icd10(diagnosis)
    case diagnosis.downcase
    when /type.*2.*diabetes/ then 'E11.9'
    when /type.*1.*diabetes/ then 'E10.9'
    when /diabetes/ then 'E11.9'
    when /hypertension/ then 'I10'
    when /hyperlipidemia|dyslipidemia/ then 'E78.5'
    when /asthma/ then 'J45.9'
    when /copd/ then 'J44.1'
    when /pneumonia/ then 'J18.9'
    when /bronchitis/ then 'J40'
    else nil
    end
  end
end

# parts/patient/controllers/patients_lhr_controller.rb
class PatientsLhrController < ApiController
  before_action :set_clinic_patient
  
  def show
    result = Patients::GetLongitudinalHealthRecord.call(
      patient_id: params[:patient_id],
      clinic_id: current_user.clinic_id
    )
    
    if result.success?
      render json: result.longitudinal_data
    else
      render_result(result)
    end
  end
  
  def problems
    result = PatientProblems::Index.call(
      patient_id: params[:patient_id],
      clinic_id: current_user.clinic_id
    )
    render_result(result, result.success? ? PatientProblemSerializer : nil)
  end
  
  def medications_timeline
    result = MedicationRequests::Timeline.call(
      patient_id: params[:patient_id],
      clinic_id: current_user.clinic_id
    )
    render_result(result, result.success? ? MedicationEventSerializer : nil)
  end
  
  def vitals_trends
    result = Patients::GetVitalsTrends.call(
      patient_id: params[:patient_id],
      clinic_id: current_user.clinic_id,
      date_range: params[:date_range]
    )
    render_result(result, result.success? ? VitalsTrendSerializer : nil)
  end
  
  private
  
  def set_clinic_patient
    @clinic_patient = ClinicPatient.find_by!(
      clinic_id: current_user.clinic_id,
      patient_id: params[:patient_id]
    )
  rescue ActiveRecord::RecordNotFound
    render json: { error: 'Patient not found in clinic' }, status: :not_found
  end
end

# parts/patient/routes.rb
Rails.application.routes.draw do
  namespace :api do
    # Legacy support (temporary - remove after frontend migration)
    resources :careplans, controller: :prescriptions
    
    # New endpoints
    resources :prescriptions do
      member do
        post :finalize # Trigger FHIR resource creation
      end
    end
    
    resources :medication_requests
    resources :service_requests
    resources :patient_problems
    resources :care_plans
    resources :clinical_observations
    resources :diagnostic_reports
    
    # LHR endpoints (matches existing frontend URL structure)
    resources :patients do
      member do
        get :longitudinal_health_record, to: 'patients_lhr#show'
        get :problems, to: 'patients_lhr#problems'
        get :medications_timeline, to: 'patients_lhr#medications_timeline'
        get :vitals_trends, to: 'patients_lhr#vitals_trends'
      end
    end
  end
end