class School::Legacy::PansController < ApplicationController
  before_action :authenticate_permissions!

  def index
    objects =
      if params[:scope]&.to_sym == :inbox
        pan_messages.map { |m|  message_props(m.pan_message, :from, m) }
      else
        pan_messages(true).map { |m| message_props(m, :to) }
      end
    render_success :ok, json: objects
  end

  def show
    pan_recipient = pan_messages.find_by(pan_message: pan_message)
    pan_recipient&.update(closed: true)
    render_success :ok, json: message_props(pan_message, :both).merge(body: pan_message.body)
  end

  def create
    pan_message = pan_messages(true).build(message_params)
    if pan_message.save
      render_success :ok, object: 'Message', json: message_props(pan_message, :to)
    else
      render_error :unprocessable_entity, errors: pan_message
    end
  end

  def destroy
    pan = pan_messages(params[:scope] == 'sent').find_by(id: params[:id])
    if pan.update(deleted: true)
      render_success :ok, object: 'Message'
    else
      render_error :unprocessable_entity, errors: pan_message
    end
  end

  private
    def authenticate_permissions!
      return if role == :employee
      return if role == :family && school_config.family_pan?
      return if role == :student && school_config.student_pan?

      render_error :forbidden, message: 'Pans not enabled'
    end

    def school_config
      @school_config ||= current_school.school_config
    end

    def pan_messages(sent=false)
      sent ? current_user.pan_messages.ordered : current_user.pan_recipients.not_deleted.ordered
    end

    def pan_message
      @pan_message ||= current_school.pan_messages
        .to_or_from(current_user.id)
        .find(params[:id])
    end

    def message_params
      params.permit(:subject, :body).merge(
        school: current_school,
        date: Time.zone.now,
        recipients: params[:recipients]
      )
    end

    def message_props(message, to_from_or_both, pan_recipient=nil)
      {}.tap do |props|
        props[:id] = message.id
        props[:subject] = message.subject
        props[:date] = message.decorate.date
        props[:from] = user_props(message.user) if [:from, :both].include?(to_from_or_both)

        if pan_recipient
          props[:pan_recipient_id] = pan_recipient.id
          props[:read] = pan_recipient.closed
        end

        props[:to] =
          if pan_recipient && to_from_or_both == :both
            user_props(pan_recipient.recipient)
          elsif [:to, :both].include?(to_from_or_both)
            message.pan_recipients.map { |r| user_props(r.recipient) }
          end
      end
    end

    def user_props(user)
      {
        id: user&.id,
        name: user&.full_name,
        full_name: user&.full_name(:reverse),
        role: user&.role
      }
    end
end