api/app/models/user.rb

class User < ApplicationRecord
    include Devise::JWT::RevocationStrategies::JTIMatcher

    devise :database_authenticatable, :registerable,
            :validatable, :jwt_authenticatable, jwt_revocation_strategy: self
    # Include default devise modules. Others available are:
    # :recoverable, :rememberable, :confirmable, :lockable, :timeoutable, :trackable and :omniauthable

    # role-based authorization
    enum :role, { member: 0, employer: 1, broker: 2, provider: 3, carrier: 4, admin: 5 }

    attr_accessor :keychain 
    attr_accessor :date_of_birth
    attr_accessor :last_four_ssn

    # validations so your db doesn't turn into a trash can
    validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
    validates :password, presence: true, length: { minimum: 6 }, if: -> { new_record? || !password.nil? }

    validates :role, presence: true
    validates :role_id, presence: true

    validate :role_entity_exists, on: :create

    # after_initialize :keychain
    before_validation :sync_role_entity, on: :create


    def keychain
        @keychain ||=   case role
                        when "member"
                            if role_entity.present?
                                # belongs_to = {
                                #     employer_id: role_entity.employer_id,
                                #     broker_id: role_entity&.baclight_employer.broker_id,
                                #     carrier_id:role_entity&.baclight_employer&.baclight_broker&.carrier_id
                                # }
                                keys = role_entity.attributes.with_indifferent_access.slice(
                                    :id, :name, :family_id, :mb_member_key, :pb_entity_key, :pl_plan_key
                                )

                                keys #.merge(belongs_to)
                            end
                        when "employer"
                            if role_entity.present?
                                belongs_to = role_entity.joins(broker: :carrier).select(
                                    'brokers.id AS broker_id', 
                                    'carriers.id AS carrier_id'
                                )


                                keys = role_entity.attributes.with_indifferent_access.slice(
                                    :name, :pl_plan_key, :company_pb_entity_key, :plan_id, :group_number
                                )

                                keys.merge(belongs_to)
                            end
                        when "broker"
                            if role_entity.present?
                                belongs_to = role_entity.joins(:carrier).select(
                                    'carriers.id AS carrier_id'
                                )
                                role_entity.attributes.with_indifferent_access.slice(
                                    :name, :id
                                ).merge(belongs_to)
                            end
                        when "provider"
                            if role_entity.present?
                                role_entity.attributes.with_indifferent_access.slice(
                                    :name, :pb_entity_key, :tax_id, :family_id
                                )
                            end
                        when "carrier"
                            if role_entity.present?
                                role_entity.attributes.with_indifferent_access.slice(
                                    :name, :id
                                )
                            end
                        # when "admin"
                        end
    end

    private

    def role_entity
        @role_entity =  case role
                        when "member"
                            if self.persisted?
                                Baclight::Member.find_by(pb_entity_key: role_id)
                            else
                                find_initial_member
                            end
                        when "employer"
                            Baclight::Employer.find_by(company_pb_entity_key: role_id)
                        when "broker"
                            Baclight::Broker.find_by(broker_id: role_id)
                        when "provider"
                            Baclight::Provider.find_by(tax_id: role_id)
                        when "carrier"
                            Baclight::Carrier.find_by(carrier_id: role_id)
                        # when "admin"
                        end
    end

    def sync_role_entity
        if role == "member"
            self.name = role_entity.name.split(",").reverse.join(" ").squish
        else
            self.name = role_entity.name
        end
    end

    def role_entity_exists
        if role_entity.blank?
            errors.add(:role, "#{role} with id #{role_id} was not found.")
        end
        if role == "member"
            dob = Vhcs::VwmbMember.find_by(pb_entity_key: role_id).date_of_birth
            unless dob == date_of_birth
                errors.add(:role, "#{role} with id #{role_id} and #{date_of_birth} was not found.")
            end
        end
    end

    def find_initial_member
        initial_member = Vhcs::VwmbMember.where("RIGHT(SocialSecurityNumber, 4) = ? AND DateOfBirth = ?", last_four_ssn, date_of_birth).first
        self.role_id = initial_member&.pb_entity_key
        member = Baclight::Member.find_by(pb_entity_key: role_id)
        member.presence
    end

end