```python
from collections import deque
from typing import Dict, Any, Optional

class JobQueue:
    """
    A basic, in-memory job queue implementation.
    """
    def __init__(self):
        # Queue for jobs waiting to be processed (FIFO)
        # Stores tuples: (job_id, data)
        self._pending_jobs: deque[tuple[str, Dict[str, Any]]] = deque()
        
        # Dictionary to store results of completed jobs
        self._job_results: Dict[str, Dict[str, Any]] = {}
        
        # Dictionary to track if a job has been processed/completed
        self._job_status: Dict[str, str] = {}

    def add_job(self, job_id: str, data: Dict[str, Any]) -> str:
        """
        Adds a job to the queue.

        :param job_id: Unique identifier for the job.
        :param data: Payload data for the job.
        :return: The job_id.
        """
        if job_id in self._job_status:
            raise ValueError(f"Job ID {job_id} already exists.")
            
        self._pending_jobs.append((job_id, data))
        self._job_status[job_id] = "PENDING"
        return job_id

    def get_result(self, job_id: str) -> Optional[Dict[str, Any]]:
        """
        Retrieves the result of a completed job.

        :param job_id: Unique identifier of the job.
        :return: The job result dictionary, or None if not found/completed.
        """
        if job_id not in self._job_results:
            return None
        return self._job_results[job_id]

    def _process_next_job(self) -> Optional[str]:
        """
        Internal method to simulate processing the next job in FIFO order.
        
        In a real system, this would be handled by a worker thread.
        """
        if not self._pending_jobs:
            return None

        job_id, data = self._pending_jobs.popleft()
        self._job_status[job_id] = "PROCESSING"
        
        print(f"--- Processing Job: {job_id} with data: {data}")

        # --- Simulation of Job Execution ---
        
        # Simulate work completion
        import time
        time.sleep(0.1) 
        
        # Simulate generating a result based on input data
        result = {
            "status": "COMPLETED",
            "processed_data": data.get("task", "No task specified"),
            "timestamp": time.time()
        }
        
        # Store the result and update status
        self._job_results[job_id] = result
        self._job_status[job_id] = "COMPLETED"
        
        print(f"--- Job {job_id} finished.")
        return job_id

# Example Usage:
if __name__ == '__main__':
    queue = JobQueue()
    
    # 1. Add jobs
    job_id_1 = queue.add_job("job1", {"task": "process_data_A", "priority": 1})
    job_id_2 = queue.add_job("job2", {"task": "cleanup_files", "priority": 2})
    job_id_3 = queue.add_job("job3", {"task": "generate_report", "priority": 3})

    print("\n--- Initial State ---")
    print(f"Job 1 added: {job_id_1}")
    print(f"Job 2 added: {job_id_2}")
    print(f"Job 3 added: {job_id_3}")
    
    # 2. Process jobs (Simulating worker activity)
    print("\n--- Starting Processing Cycle 1 ---")
    processed_id = queue._process_next_job()
    print(f"Processed: {processed_id}")

    print("\n--- Starting Processing Cycle 2 ---")
    processed_id = queue._process_next_job()
    print(f"Processed: {processed_id}")

    # 3. Check results while jobs are still pending
    print("\n--- Checking Results Before Final Job ---")
    result_1 = queue.get_result("job1")
    print(f"Result for job1 (should be present): {result_1['status'] if result_1 else 'None'}")
    
    result_3 = queue.get_result("job3")
    print(f"Result for job3 (should be None): {result_3}")

    # 4. Process the final job
    print("\n--- Starting Processing Cycle 3 ---")
    processed_id = queue._process_next_job()
    print(f"Processed: {processed_id}")

    # 5. Check final results
    print("\n--- Final Checks ---")
    result_3_final = queue.get_result("job3")
    print(f"Final Result for job3: {result_3_final}")
    
    # Check non-existent job
    result_4 = queue.get_result("job4")
    print(f"Result for job4 (non-existent): {result_4}")
```