Implement multi-level task manager APIs

You are implementing an in-memory task management system with a set of APIs that evolve over 4 levels. All APIs receive a timestamp: int parameter. Unless otherwise stated, timestamps are integers and can be assumed to be non-decreasing across calls (you may state and rely on this if needed).

Task IDs are generated sequentially as strings:

• First task is "task_id_1" , then "task_id_2" , etc.
• Creation order is the numeric suffix order (e.g., task_id_2 comes before task_id_10 ).

A task has:

• name: str
• priority: int (non-negative, >= 0 )

Assignments (introduced later) are time-based.

Level 1: Basic task CRUD

Implement the following:

1. add_task(self, timestamp: int, name: str, priority: int) -> str
   • Adds a new task with the given name and priority .
   • Returns the unique task ID.
   • Adding multiple tasks with the same name and priority is allowed; tasks are differentiated by ID.
   • Note: timestamp is unused in Level 1 logic; included for API consistency.
2. update_task(self, timestamp: int, task_id: str, name: str, priority: int) -> bool
   • Updates the name and priority of the task identified by task_id .
   • Returns True if update succeeds; False if task_id does not exist.
3. get_task(self, timestamp: int, task_id: str) -> str | None
   • Retrieves a task by task_id .
   • If it exists, return a JSON-formatted string containing the task details ( name and priority ).
   • If it does not exist, return None .

Level 2: Searching and sorting tasks

Add the following APIs:

1. search_tasks(self, timestamp: int, name_filter: str, max_results: int) -> list[str]
   • Finds tasks whose name contains name_filter as a case-sensitive substring .
   • Returns up to max_results matching task IDs .
   • Sort results by:
     1. priority descending, then
     2. creation order ascending.
   • If max_results <= 0 , return [] .
2. list_tasks_sorted(self, timestamp: int, limit: int) -> list[str]
   • Returns up to limit task IDs across the system.
   • Sorting is the same: priority descending, then creation order ascending.

Level 3: Users and time-based task assignments

Introduce users with quotas and time-windowed assignments.

1. add_user(self, timestamp: int, user_id: str, quota: int) -> bool
   • Adds a new user with a maximum number of simultaneously active assignments ( quota ).
   • Returns True if added, False if user_id already exists.
2. assign_task(self, timestamp: int, task_id: str, user_id: str, finish_time: int) -> bool
   • Assigns task_id to user_id for the time interval [timestamp, finish_time) .
   • The assignment is active at time t iff start_time <= t < finish_time .
   • Returns True if successful; otherwise False if:
     • the task does not exist, or
     • the user does not exist, or
     • the user's quota is already fully used by currently active assignments.
   • Each successful active assignment consumes one quota slot while it remains active.
3. get_user_tasks(self, timestamp: int, user_id: str) -> list[str]
   • Returns all active task IDs assigned to user_id at the given timestamp .
   • Only include assignments where start_time <= timestamp < finish_time .

Level 4: Completion and overdue detection

Add completion and overdue queries.

1. complete_task(self, timestamp: int, task_id: str, user_id: str) -> bool
   • Marks a task as completed by user_id at time timestamp .
   • The task must be assigned to the user and active at timestamp .
   • When completed, the user's quota slot is freed immediately .
   • Returns True if successful; otherwise False if:
     • task does not exist, or
     • user does not exist, or
     • task is not assigned to the user at timestamp .
2. get_overdue_assignments(self, timestamp: int, user_id: str) -> list[str]
   • Returns task IDs for assignments that were given to user_id and expired without completion .
   • An assignment is overdue if:
     • finish_time <= timestamp , and
     • the task was not completed before the finish_time of that specific assignment .

Implement the full system so that all levels work together consistently. Clarify any additional assumptions you need (e.g., whether timestamps are non-decreasing, whether a task can be assigned multiple times, and how repeated assignments to the same user/task should behave), but your behavior must remain consistent with the definitions above.