# frozen_string_literal: true

module FacultyRBAC
  # Permits RBAC queries relating to a specific role
  class Role
    GROUPS_QUERY = %(
      select distinct group_id
      from rbac_group_role gr
      where gr.role_id = ?
    )

    def self.create(controller, role_name)
      rid = controller.db[:rbac_role].insert(name: role_name.to_s)
      Role.new(controller, rid, role_name)
    end

    def self.by_name(controller, role_name)
      rid = controller.db[:rbac_role].where(name: role_name.to_s).get(:id)
      Role.new(controller, rid, role_name)
    end

    def initialize(controller, role_id, role_name)
      @id = role_id.to_i
      @name = role_name.to_s
      @controller = controller
    end

    attr_reader :id, :name

    def to_i
      @id
    end

    def to_s
      @name
    end

    def _db
      @controller.db
    end

    def delete
      _db[:rbac_role].where(id: @id).delete
    end

    def permissions
      _db[:rbac_permission].where(role_id: @id).map do |permission|
        Permission.new(permission[:name], permission[:filter], permission[:filter_params], id: permission[:id])
      end
    end

    def add_permissions(*permissions)
      ids = _db[:rbac_permission].import(
        %i[role_id name filter filter_params],
        permissions.map { |p| [@id, p.name, p.filter, p.filter_params] },
        return: :primary_key
      ) || []
      ids.zip(permissions).each { |id, p| p.id = id }
    end

    def remove_permissions(*permissions)
      pids = permissions.map(&:to_i)
      pids.delete(nil)
      _db[:rbac_permission].where(role_id: @id, id: pids).delete
    end

    def grants
      _db[:rbac_grant].where(role_id: @id).map { |grant| Grant[@controller, grant] }
    end

    def grant(*group_ids, **arguments)
      missing_params = (_required_parameters - arguments.keys.map(&:to_s))
      raise KeyError, "Missing parameters: #{missing_params.join(', ')}" unless missing_params.empty?

      _apply_grants(group_ids, JSON.generate(arguments))
    end

    private

    def _required_parameters
      permissions.flat_map { |p| p.filter_params.values }.uniq
    end

    def _apply_grants(group_ids, filter_arg_json)
      ids = _db[:rbac_grant].import(
        %i[group_id role_id filter_args],
        group_ids.map { |group_id| [group_id.to_i, @id, filter_arg_json] },
        return: :primary_key
      ) || []
      ids.zip(group_ids).map do |id, group_id|
        Grant.new(@controller, id, self, group_id, filter_arg_json)
      end
    end
  end
end