class Maintenance::Admissions::CleanupJob
  include Sidekiq::Worker

  def perform(school_id)
    @school_id = school_id

    # Set review = true for pre-applicants
    pre_applicants = school.admission_applicants.with_state([:unsubmitted, :submitted])
    pre_applicants.update_all(review: true)

    # Create missing profile field records for each existing application
    required_fields = Admission::ProfileField::REQUIRED_FIELDS
    school.admission_applications.includes(:profile_fields).each do |application|
      fields = application.profile_fields.map(&:field)
      missing_fields = Admission::ProfileField.fields.keys - fields
      next if missing_fields.empty?

      missing_fields.each do |field|
        application.profile_fields.create(
          field: field,
          display: required_fields.include?(field),
          required: required_fields.include?(field)
        )
      end
    end

    # Create missing registration field records
    required_fields = Admission::RegistrationField::REQUIRED_FIELDS
    fields = school.admission_registration_fields.pluck(:field)
    missing_fields = Admission::RegistrationField.fields.keys - fields
    missing_fields.each do |field|
      school.admission_registration_fields.create(
        field: field,
        display: required_fields.include?(field),
        required: required_fields.include?(field),
      )
    end

    # Migrate applicant documents to Google
    applicant_documents.each do |document|
      document.file.attach(
        io: File.open(document.file_path),
        filename: document.filename
      )
    end

    # Migrate attachments to Google
    attachments.each do |attachment|
      attachment.file.attach(
        io: File.open(attachment.file_path),
        filename: attachment.filename
      )
    end

    # Migrate applicant application pdfs to Google
    applicants = school.admission_applicants
      .preload(:admission_application)
      .joins(:admission_application)

    applicants.each(&:migrate_pdf)

    # Enable admission employee module & user permission
    if school.school_config.admissions? || school.school_config.Admission?
      module_config = school.find_or_build_employee_module
      module_config.update(admissions: true)

      school.employees.where(id: users_with_legacy_permission).each do |employee|
        permission = employee.find_or_build_admin_permission
        permission.admissions_manage!
      end
    end
  end

  private
    def school
      @school ||= School.find(@school_id)
    end

    def applicant_documents
      school.admission_applicant_documents
        .left_joins(:file_attachment)
        .where(active_storage_attachments: { id: nil })
    end

    def attachments
      school.admission_attachments
        .left_joins(:file_attachment)
        .where(active_storage_attachments: { id: nil })
    end

    def users_with_legacy_permission
      school.permission_users.where(name: :CoEnrollment).pluck(:user_id)
    end
end