<reasoning_content>
*   Goal: Implement priority-based job scheduling for a queue.
    *   Requirements:
        1.  `add_job` must accept an optional `priority` parameter (default=0).
        2.  Higher priority comes first (Higher priority number = higher priority? Let's check the example).
            *   Example: "normal" (0), "critical" (2), "high" (1).
            *   Result: "critical" (2) is first.
            *   So, Higher priority value = processed first.
        3.  Same priority = FIFO order.
        4.  `get_next_job()` must return the highest priority job or `None`.
    *   Output: Python code only.

    *   A `heapq` is perfect for priority queues.
    *   Standard `heapq` is a min-heap.
    *   The priorities are: 0 (Normal), 1 (High), 2 (Critical).
    *   If I use a min-heap, I need to store the priority as a negative number (e.g., -2, -1, 0) to make 2 come out before 0.
    *   OR, since the requirement says "Higher priority jobs should be processed before lower priority jobs" and the example shows 2 > 1 > 0 being processed in that order, I can use a max-heap logic.
    *   To maintain FIFO for same priority in a heap, I need a secondary counter (serial number) to break ties.

    *   `self.jobs = []` (list to be used with `heapq`).
    *   `self.counter = 0` (to preserve FIFO).

    *   `add_job(name, data, priority=0)`:
        *   Push `(-priority, self.counter, name, data)` into the heap.
        *   Increment `self.counter`.

    *   `get_next_job()`:
        *   `heapq.heappop()` if not empty.
        *   Return `(name, data)`.

    *   The prompt asks to modify `add_job` and add `get_next_job`. This implies a class structure `JobQueue`.

    *   Priority 2 (Critical) > 1 (High) > 0 (Normal).
    *   If I use `heapq` (min-heap), I must use `-priority`.
    *   Let's double check:
        *   `add_job("normal", ..., priority=0)` -> heap item `(0, 0, "normal", ...)`
        *   `add_job("critical", ..., priority=2)` -> heap item `(-2, 1, "critical", ...)`
        *   `add_job("high", ..., priority=1)` -> heap item `(-1, 2, "high", ...)`
        *   Popping: `-2` comes first. Correct.

    Wait, if I want to follow "Higher priority jobs should be processed before lower priority jobs", and 2 is higher than 0, then a max-heap is needed.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self.queue = []
            self.counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Use -priority because heapq is a min-heap
            # counter ensures FIFO for same priority
            heapq.heappush(self.queue, (-priority, self.counter, name, data))
            self.counter += 1

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self.queue:
                return None
            _, _, name, data = heapq.heappop(self.queue)
            return (name, data)
    ```

    *   Requirement 1: `add_job` accepts `priority=0`. Check.
    *   Requirement 2: Higher priority first. Check.
    *   Requirement 3: Same priority FIFO. Check (the `counter` handles this).
    *   Requirement 4: `get_next_job` returns `tuple[str, dict] | None`. Check.

    Actually, I should check if there's any ambiguity about "Higher priority". Usually, 0 is highest in some systems, but the example clearly shows 2 comes before 1 and 0.

    Wait, the example:
    `queue.add_job("normal", ..., priority=0)`
    `queue.add_job("critical", ..., priority=2)`
    `queue.add_job("high", ..., priority=1)`
    `queue.get_next_job()` -> returns "critical".
    So 2 > 1 > 0.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self.queue = []
            self.counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # heapq is a min-heap, so we negate the priority to prioritize higher numbers
            heapq.heappush(self.queue, (-priority, self.counter, name, data))
            self.counter += 1

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self.queue:
                return None
            _, _, name, data = heapq.heappop(self.queue)
            return (name, data)
    ```

    Wait, do I need to include `import heapq`? Yes.
    Should I use a list and sort it? No, `heapq` is the standard way for priority queues.

    One more check: "Jobs with the same priority should maintain FIFO order".
    If I have:
    `add_job("a", ..., priority=1)` -> `(-1, 0, "a", ...)`
    `add_job("b", ..., priority=1)` -> `(-1, 1, "b", ...)`
    `heappop` will return `(-1, 0, ...)` first. Correct.

    Double check types: `tuple[str, dict] | None`. Python 3.10+ syntax is allowed as per standard practice.

    One detail: `priority` is an integer.

    ```python
    import heapq

    class JobQueue:
        def __init__(self):
            self._queue = []
            self._counter = 0

        def add_job(self, name: str, data: dict, priority: int = 0):
            # Use negative priority for max-heap behavior with heapq (min-heap)
            # Use counter to maintain FIFO for same priority
            heapq.heappush(self._queue, (-priority, self._counter, name, data))
            self._counter += 1

        def get_next_job(self) -> tuple[str, dict] | None:
            if not self._queue:
                return None
            _, _, name, data = heapq.heappop(self._queue)
            return (name, data)
    ```

    Wait, did the prompt ask for a specific class structure? It says "Modify `add_job`... Add `get_next_job()`...". This implies a class `JobQueue`.

    The prompt shows:
    ```python
    queue = JobQueue()
    queue.add_job("normal", {"type": "normal"}, priority=0)
    ...
    ```
    So yes, a class is expected.

    Final check on priority logic:
    `priority=2` (Critical)
    `priority=1` (High)
    `priority=0` (Normal)
    `heappush` with negative values:
    -2, -1, 0.
    Min heap will pop -2 first. Correct.
</reasoning_content>

<content>
```python
import heapq

class JobQueue:
    def __init__(self):
        self._queue = []
        self._counter = 0

    def add_job(self, name: str, data: dict, priority: int = 0):
        # heapq is a min-heap. To treat higher numbers as higher priority,
        # we store priority as a negative value.
        # The counter ensures FIFO order for jobs with the same priority.
        heapq.heappush(self._queue, (-priority, self._counter, name, data))
        self._counter += 1

    def get_next_job(self) -> tuple[str, dict] | None:
        if not self._queue:
            return None
        
        _, _, name, data = heapq.heappop(self._queue)
        return (name, data)
```
</content>