Take into account mapping when updating server_1_watched

Signed-off-by: Luis Garcia <[email protected]>

src/watched.py

@@ -44,48 +44,78 @@ class UserData(BaseModel):
 
 def merge_library_data(lib1: LibraryData, lib2: LibraryData) -> LibraryData:
     """
-    Merge two LibraryData objects by extending the movies and series lists.
-    Assumes both libraries have the same title.
+    Merge two LibraryData objects by extending their movies and series lists.
+    Assumes that the libraries represent the same data.
     """
-    # Work on a copy to avoid modifying the original object
     merged = copy.deepcopy(lib1)
     merged.movies.extend(lib2.movies)
     merged.series.extend(lib2.series)
     return merged
 
 
-def merge_user_data(user1: UserData, user2: UserData) -> UserData:
-    """
-    Merge two UserData objects by merging their libraries.
-    If a library exists in both, merge its content;
-    otherwise, add the new library from user2.
-    """
-    merged_libraries = copy.deepcopy(user1.libraries)
-    for lib_key, lib_data in user2.libraries.items():
-        if lib_key in merged_libraries:
-            merged_libraries[lib_key] = merge_library_data(
-                merged_libraries[lib_key], lib_data
-            )
-        else:
-            merged_libraries[lib_key] = copy.deepcopy(lib_data)
-    return UserData(libraries=merged_libraries)
-
-
 def merge_server_watched(
-    server1: dict[str, UserData], server2: dict[str, UserData]
+    watched_list_1: dict[str, UserData],
+    watched_list_2: dict[str, UserData],
+    user_mapping: dict[str, str] | None = None,
+    library_mapping: dict[str, str] | None = None,
 ) -> dict[str, UserData]:
     """
-    Merge two dictionaries of UserData.
-    For overlapping user keys, merge their data.
-    For new users from server2, add them directly.
+    Merge two dictionaries of UserData while taking into account possible
+    differences in user and library keys via the provided mappings.
+
+    For each user in watched_list_2:
+      - If a matching user exists in watched_list_1 (either directly or via user_mapping),
+        then for each library in that user, merge the library data if a corresponding
+        library exists (via library_mapping) or add the library if it does not.
+      - If no matching user exists, add the entire user from watched_list_2.
     """
-    merged = copy.deepcopy(server1)
-    for user, user_data in server2.items():
-        if user in merged:
-            merged[user] = merge_user_data(merged[user], user_data)
+    merged_watched = copy.deepcopy(watched_list_1)
+
+    for user2_key, user2_data in watched_list_2.items():
+        # Determine the corresponding user key in merged_watched.
+        if user2_key in merged_watched:
+            user1_key = user2_key
         else:
-            merged[user] = copy.deepcopy(user_data)
-    return merged
+            # Look up a reverse mapping (e.g. a key in watched_list_1 that maps to user2_key)
+            user1_key = next(
+                (
+                    k
+                    for k, mapped in (user_mapping or {}).items()
+                    if mapped == user2_key
+                ),
+                None,
+            )
+
+        if user1_key is None:
+            # No matching user exists; add the entire user entry.
+            merged_watched[user2_key] = copy.deepcopy(user2_data)
+            continue
+
+        # Merge libraries for the matching user.
+        for lib2_key, lib2_data in user2_data.libraries.items():
+            user1_libraries = merged_watched[user1_key].libraries
+            if lib2_key in user1_libraries:
+                lib1_key = lib2_key
+            else:
+                # Look up the library mapping.
+                lib1_key = next(
+                    (
+                        k
+                        for k, mapped in (library_mapping or {}).items()
+                        if mapped == lib2_key
+                    ),
+                    None,
+                )
+
+            if lib1_key is None:
+                # No matching library exists; add it directly.
+                merged_watched[user1_key].libraries[lib2_key] = copy.deepcopy(lib2_data)
+            else:
+                # Merge the two libraries.
+                merged_lib = merge_library_data(user1_libraries[lib1_key], lib2_data)
+                merged_watched[user1_key].libraries[lib1_key] = merged_lib
+
+    return merged_watched
 
 
 def check_same_identifiers(item1: MediaIdentifiers, item2: MediaIdentifiers) -> bool:
@@ -149,8 +179,8 @@ def check_remove_entry(item1: MediaItem, item2: MediaItem) -> bool:
 def cleanup_watched(
     watched_list_1: dict[str, UserData],
     watched_list_2: dict[str, UserData],
-    user_mapping=None,
-    library_mapping=None,
+    user_mapping: dict[str, str] | None = None,
+    library_mapping: dict[str, str] | None = None,
 ) -> dict[str, UserData]:
     modified_watched_list_1 = copy.deepcopy(watched_list_1)