<reasoning_content>
*   Goal: Implement priority-based job scheduling for a queue.
    *   Requirements:
        1.  `add_job(name, data, priority=0)`: Store jobs with priority.
        2.  Priority order: Higher numbers (2, 1, 0) processed first.
        3.  Tie-breaking: Same priority -> FIFO (First In, First Out).
        4.  `get_next_job() -> tuple[str, dict] | None`: Retrieve the highest priority job.
    *   Constraints: No explanations, only Python code.

    *   A simple list/queue won't work efficiently for priority unless sorted every time.
    *   A `heapq` (priority queue) is the standard Python way.
    *   `heapq` is a min-heap (smallest value comes first). Since the user wants *higher* numbers to be processed first, I need to invert the priority (e.g., use `-priority`).
    *   To handle FIFO for same priority: When priorities are equal, the heap compares the next element in the tuple. To ensure FIFO, I should include a sequence number (counter) that increments with every insertion. This way, if `-priority` is the same, the smaller `counter` (the one added earlier) comes out first.

    *   Class `JobQueue`.
    *   `__init__`: Initialize an empty list `self.queue` and a counter `self.counter = 0`.
    *   `add_job(name, data, priority=0)`:
        *   `heapq.heappush(self.queue, (-priority, self.counter, name, data))`
        *   `self.counter += 1`
    *   `get_next_job()`:
        *   If not `self.queue`, return `None`.
        *   `priority_neg, count, name, data = heapq.heappop(self.queue)`
        *   Return `(name, data)`.

    *   Priority 2 -> `-2`
    *   Priority 1 -> `-1`
    *   Priority 0 -> `0`
    *   In a min-heap: `-2 < -1 < 0`. So `-2` (Critical) comes out first. Correct.
    *   FIFO check:
        *   Job A: priority 1, counter 0 -> `(-1, 0, ...)`
        *   Job B: priority 1, counter 1 -> `(-1, 1, ...)`
        *   Min-heap pops `(-1, 0, ...)` then `(-1, 1, ...)`. Correct.

    ```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 for max-heap behavior with heapq (min-heap)
            # Use self._counter to ensure 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)
    ```

    *   `add_job` accepts `priority` (default 0).
    *   Higher priority (2) before lower (1, 0).
    *   Same priority -> FIFO.
    *   `get_next_job` returns `tuple[str, dict] | None`.

    (Wait, check return type: `tuple[str, dict] | None`. Yes.)
</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 simulate a max-priority queue, 
        # we negate the priority.
        # We include self._counter to ensure 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
        
        # Pop the element with the lowest value (highest priority due to negation)
        _, _, name, data = heapq.heappop(self._queue)
        return (name, data)
```
</content>