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.