class DraftSession

# File app/models/draft_session.rb, line 29
def initialize(current_user:, **attributes)
  @current_user = current_user
  super(**attributes)
end

# File app/models/draft_session.rb, line 353
def academic_year_date_range
  academic_year.to_academic_year_date_range
end

# File app/models/draft_session.rb, line 181
def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

# File app/models/draft_session.rb, line 322
def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

# File app/models/draft_session.rb, line 179
def dates = session_dates.map(&:value).compact.sort.uniq

def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

private

def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def latest_possible_session_date_value
  academic_year_date_range.end

# File app/models/draft_session.rb, line 338
  def earliest_date = dates.min

  def earliest_send_notifications_at
    earliest_date - 3.months
  end

  def latest_send_consent_requests_at
    earliest_date - days_before_consent_reminders.days - 1
  end

  def maximum_weeks_before_consent_reminders
    return nil if earliest_date.nil? || send_consent_requests_at.nil?
    (earliest_date - send_consent_requests_at).to_i / 7
  end

  def academic_year_date_range
    academic_year.to_academic_year_date_range
  end

  def earliest_possible_session_date_value
    academic_year_date_range.begin
  end

  def latest_possible_session_date_value
    academic_year_date_range.end
  end
end

# File app/models/draft_session.rb, line 357
def earliest_possible_session_date_value
  academic_year_date_range.begin
end

# File app/models/draft_session.rb, line 340
def earliest_send_notifications_at
  earliest_date - 3.months
end

# File app/models/draft_session.rb, line 133
def generic_clinic? = location&.generic_clinic?

def programmes = Programme.find_all(programme_types)

def new_programmes = Programme.find_all(new_programme_types)

def patient_locations
  @patient_locations ||=
    PatientLocation.where(location_id:, academic_year:).includes(:patient)
end

def programme_types=(values)
  super(values&.compact_blank || [])
end

def year_groups=(values)
  super(values&.compact_blank&.filter_map(&:to_i) || [])
end

def session_programme_year_groups
  @session_programme_year_groups ||=
    location_programme_year_groups.filter_map do |location_programme_year_group|
      year_group = location_programme_year_group.year_group
      programme_type = location_programme_year_group.programme_type

      if programme_type.in?(programme_types) && year_group.in?(year_groups)
        Session::ProgrammeYearGroup.new(programme_type:, year_group:)
      end
    end
end

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def patient_is_catch_up?(patient, programmes:)
  year_group = patient.year_group(academic_year:)
  programmes.any? { it.is_catch_up?(year_group:) }
end

def dates = session_dates.map(&:value).compact.sort.uniq

def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

private

def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def latest_possible_session_date_value

# File app/models/draft_session.rb, line 238
def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

# File app/models/draft_session.rb, line 222
def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

# File app/models/draft_session.rb, line 268
def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

# File app/models/draft_session.rb, line 361
def latest_possible_session_date_value
  academic_year_date_range.end
end

# File app/models/draft_session.rb, line 344
def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

# File app/models/draft_session.rb, line 109
def location
  return nil if location_id.nil?

  @location ||=
    LocationPolicy::Scope
      .new(@current_user, Location)
      .resolve
      .find(location_id)
end

# File app/models/draft_session.rb, line 283
def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

# File app/models/draft_session.rb, line 348
def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

# File app/models/draft_session.rb, line 279
def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

# File app/models/draft_session.rb, line 137
def new_programmes = Programme.find_all(new_programme_types)

def patient_locations
  @patient_locations ||=
    PatientLocation.where(location_id:, academic_year:).includes(:patient)
end

def programme_types=(values)
  super(values&.compact_blank || [])
end

def year_groups=(values)
  super(values&.compact_blank&.filter_map(&:to_i) || [])
end

def session_programme_year_groups
  @session_programme_year_groups ||=
    location_programme_year_groups.filter_map do |location_programme_year_group|
      year_group = location_programme_year_group.year_group
      programme_type = location_programme_year_group.programme_type

      if programme_type.in?(programme_types) && year_group.in?(year_groups)
        Session::ProgrammeYearGroup.new(programme_type:, year_group:)
      end
    end
end

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def patient_is_catch_up?(patient, programmes:)
  year_group = patient.year_group(academic_year:)
  programmes.any? { it.is_catch_up?(year_group:) }
end

def dates = session_dates.map(&:value).compact.sort.uniq

def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

private

def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def latest_possible_session_date_value
  academic_year_date_range.

# File app/models/draft_session.rb, line 201
def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

# File app/models/draft_session.rb, line 174
def patient_is_catch_up?(patient, programmes:)
  year_group = patient.year_group(academic_year:)
  programmes.any? { it.is_catch_up?(year_group:) }
end

# File app/models/draft_session.rb, line 139
def patient_locations
  @patient_locations ||=
    PatientLocation.where(location_id:, academic_year:).includes(:patient)
end

# File app/models/draft_session.rb, line 144
def programme_types=(values)
  super(values&.compact_blank || [])
end

# File app/models/draft_session.rb, line 135
def programmes = Programme.find_all(programme_types)

def new_programmes = Programme.find_all(new_programme_types)

def patient_locations
  @patient_locations ||=
    PatientLocation.where(location_id:, academic_year:).includes(:patient)
end

def programme_types=(values)
  super(values&.compact_blank || [])
end

def year_groups=(values)
  super(values&.compact_blank&.filter_map(&:to_i) || [])
end

def session_programme_year_groups
  @session_programme_year_groups ||=
    location_programme_year_groups.filter_map do |location_programme_year_group|
      year_group = location_programme_year_group.year_group
      programme_type = location_programme_year_group.programme_type

      if programme_type.in?(programme_types) && year_group.in?(year_groups)
        Session::ProgrammeYearGroup.new(programme_type:, year_group:)
      end
    end
end

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def patient_is_catch_up?(patient, programmes:)
  year_group = patient.year_group(academic_year:)
  programmes.any? { it.is_catch_up?(year_group:) }
end

def dates = session_dates.map(&:value).compact.sort.uniq

def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

private

def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def latest_possible_session_date_value
  

# File app/models/draft_session.rb, line 164
def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

# File app/models/draft_session.rb, line 206
def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

# File app/models/draft_session.rb, line 250
def readable_attribute_names
  super - %w[dates return_to session_dates]
end

# File app/models/draft_session.rb, line 248
def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def latest_possible_session_date_value
  academic_year_date_range.end
end

# File app/models/draft_session.rb, line 131
def school? = location&.gias_school?

def generic_clinic? = location&.generic_clinic?

def programmes = Programme.find_all(programme_types)

def new_programmes = Programme.find_all(new_programme_types)

def patient_locations
  @patient_locations ||=
    PatientLocation.where(location_id:, academic_year:).includes(:patient)
end

def programme_types=(values)
  super(values&.compact_blank || [])
end

def year_groups=(values)
  super(values&.compact_blank&.filter_map(&:to_i) || [])
end

def session_programme_year_groups
  @session_programme_year_groups ||=
    location_programme_year_groups.filter_map do |location_programme_year_group|
      year_group = location_programme_year_group.year_group
      programme_type = location_programme_year_group.programme_type

      if programme_type.in?(programme_types) && year_group.in?(year_groups)
        Session::ProgrammeYearGroup.new(programme_type:, year_group:)
      end
    end
end

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def patient_is_catch_up?(patient, programmes:)
  year_group = patient.year_group(academic_year:)
  programmes.any? { it.is_catch_up?(year_group:) }
end

def dates = session_dates.map(&:value).compact.sort.uniq

def can_change_year_groups?
  school? && (new_record? || !open_for_consent?)
end

def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

def next_send_consent_requests_at
  return nil if send_consent_requests_at.nil?
  [send_consent_requests_at, Date.current].max
end

def read_from!(session)
  self.session_dates =
    session.dates.each_with_index.map do |value, index|
      DraftSessionDate.new(index:, value:)
    end

  session_dates << DraftSessionDate.new if session_dates.empty?

  super(session)
end

def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

def import_session_programme_year_groups!(session)
  rows =
    session_programme_year_groups.map do
      [session.id, it.programme_type, it.year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: session.id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

def human_enum_name(attribute)
  Session.human_enum_name(attribute, send(attribute))
end

def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

private

def request_session_key = "session"

def readable_attribute_names
  super - %w[dates return_to session_dates]
end

def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

def include_notification_steps?
  dates.present? &&
    (
      session.nil? ||
        (
          session.consent_notifications.empty? &&
            session.session_notifications.empty?
        )
    )
end

def new_programme_types
  @new_programme_types ||= programme_types - (session&.programme_types || [])
end

def location_programme_year_groups
  @location_programme_year_groups ||=
    location.location_programme_year_groups.includes(:location_year_group)
end

def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

def cannot_remove_programmes
  if editing? && (session.programme_types - programme_types).present?
    errors.add(:programme_types, :inclusion)
  end
end

def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

def earliest_date = dates.min

def earliest_send_notifications_at
  earliest_date - 3.months
end

def latest_send_consent_requests_at
  earliest_date - days_before_consent_reminders.days - 1
end

def maximum_weeks_before_consent_reminders
  return nil if earliest_date.nil? || send_consent_requests_at.nil?
  (earliest_date - send_consent_requests_at).to_i / 7
end

def academic_year_date_range
  academic_year.to_academic_year_date_range
end

def earliest_possible_session_date_value
  academic_year_date_range.begin
end

def

# File app/models/draft_session.rb, line 98
def session
  return nil if editing_id.nil?

  @session ||=
    SessionPolicy::Scope.new(@current_user, Session).resolve.find(editing_id)
end

# File app/models/draft_session.rb, line 105
def session=(value)
  self.editing_id = value.id
end

# File app/models/draft_session.rb, line 152
def session_programme_year_groups
  @session_programme_year_groups ||=
    location_programme_year_groups.filter_map do |location_programme_year_group|
      year_group = location_programme_year_group.year_group
      programme_type = location_programme_year_group.programme_type

      if programme_type.in?(programme_types) && year_group.in?(year_groups)
        Session::ProgrammeYearGroup.new(programme_type:, year_group:)
      end
    end
end

# File app/models/draft_session.rb, line 185
def set_notification_dates
  if earliest_date
    if generic_clinic?
      self.days_before_consent_reminders = nil
      self.send_consent_requests_at = nil
    else
      self.days_before_consent_reminders = team.days_before_consent_reminders
      self.send_consent_requests_at =
        earliest_date - team.days_before_consent_requests.days
    end
  else
    self.days_before_consent_reminders = nil
    self.send_consent_requests_at = nil
  end
end

# File app/models/draft_session.rb, line 242
def supports_outbreak?
  programmes.any?(&:supports_outbreak?)
end

# File app/models/draft_session.rb, line 119
def team
  return nil if team_id.nil?

  @team ||= TeamPolicy::Scope.new(@current_user, Team).resolve.find(team_id)
end

# File app/models/draft_session.rb, line 125
def team_location
  @team_location ||= TeamLocation.find_by!(team:, location:, academic_year:)
end

# File app/models/draft_session.rb, line 328
def valid_school_ids
  LocationPolicy::Scope
    .new(@current_user, Location)
    .resolve
    .gias_school
    .joins(:team_locations)
    .where(team_locations: { team:, academic_year: })
    .pluck(:"locations.id")
end

# File app/models/draft_session.rb, line 288
def valid_session_dates
  session_dates.each_with_index do |session_date, index|
    value = session_date.value

    next if value.nil?

    if value < earliest_possible_session_date_value
      session_date.errors.add(
        :value,
        :greater_than_or_equal_to,
        count: earliest_possible_session_date_value
      )
    elsif value > latest_possible_session_date_value
      session_date.errors.add(
        :value,
        :less_than_or_equal_to,
        count: latest_possible_session_date_value
      )
    elsif session_dates[...index].any? { it.value == value }
      session_date.errors.add(:value, :taken)
    end
  end

  return if session_dates.all? { it.errors.empty? }

  session_dates.each_with_index do |session_date, index|
    session_date.errors.messages.each do |field, messages|
      messages.each do |message|
        errors.add("session-date-#{index}-#{field}", message)
      end
    end
  end
end

# File app/models/draft_session.rb, line 34
def wizard_steps
  steps = []

  steps << :school if new_record?

  steps << :programmes
  steps << :programmes_check
  steps << :year_groups if can_change_year_groups?

  steps << :dates
  steps << :dates_check if school?

  steps << :consent_style if supports_outbreak?

  if include_notification_steps? && school?
    steps += %i[consent_requests consent_reminders]
  end

  steps << :register_attendance

  steps << :delegation if supports_delegation?

  steps + %i[confirm]
end

# File app/models/draft_session.rb, line 254
def writable_attribute_names
  super -
    %w[
      academic_year
      dates
      location_id
      programme_types
      return_to
      session_dates
      team_id
      year_groups
    ] + %w[team_location_id]
end

# File app/models/draft_session.rb, line 217
def write_to!(session)
  super(session)
  session.dates = dates.sort.uniq
end

# File app/models/draft_session.rb, line 148
def year_groups=(values)
  super(values&.compact_blank&.filter_map(&:to_i) || [])
end