<reasoning_content>
*   Goal: Implement a priority-based job scheduling system for a queue.
    *   Requirements:
        1.  `add_job(name, data, priority=0)`: Add a job.
        2.  Higher priority values (2 > 1 > 0) mean higher priority.
        3.  Same priority -> FIFO (First-In-First-Out).
        4.  `get_next_job() -> tuple[str, dict] | None`: Return the highest priority job and remove it.
    *   Constraint: Write only Python code, no explanations.

    *   Standard `heapq` in Python implements a min-heap.
    *   For a max-heap (higher priority first), we can negate the priority value when pushing.
    *   To maintain FIFO for same priority, we need a tie-breaker. A monotonic counter (sequence number) works perfectly.
    *   Structure of elements in the heap: `(-priority, sequence_number, job_name, job_data)`.
        *   `-priority`: Higher priority (e.g., 2) becomes lower value (-2) for the min-heap.
        *   `sequence_number`: Ensures FIFO for equal priorities.
        *   `job_name` and `job_data`: The actual payload.

    *   `import heapq`
    *   `import itertools` (for the sequence counter)

    *   `__init__`: `self.heap = []`, `self.counter = itertools.count()`
    *   `add_job(name, data, priority=0)`:
        *   `count = next(self.counter)`
        *   `heapq.heappush(self.heap, (-priority, count, name, data))`
    *   `get_next_job()`:
        *   If `not self.heap`, return `None`.
        *   `_, _, name, data = heapq.heappop(self.heap)`
        *   `return (name, data)`

    *   `priority=2` -> `heapq` sees `-2`.
    *   `priority=1` -> `heapq` sees `-1`.
    *   `priority=0` -> `heapq` sees `0`.
    *   Min-heap will pop `-2` first. Correct.
    *   If `priority=2` (item A) and `priority=2` (item B):
        *   A: `(-2, 0, ...)`
        *   B: `(-2, 1, ...)`
        *   Heap pops `(-2, 0, ...)` first. Correct (FIFO).
</reasoning_content>

<content>
```python
import heapq
import itertools

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

    def add_job(self, name: str, data: dict, priority: int = 0):
        # We use -priority because heapq is a min-heap, 
        # but we want higher numbers to have higher priority.
        # The counter ensures FIFO order for jobs with the same priority.
        count = next(self._counter)
        heapq.heappush(self._queue, (-priority, count, name, data))

    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>