Fix

src/watched.py

@@ -42,17 +42,89 @@ class UserData(BaseModel):
     libraries: dict[str, LibraryData] = {}
 
 
+def merge_mediaitem_data(ep1: MediaItem, ep2: MediaItem) -> MediaItem:
+    """
+    Merge two MediaItem episodes by comparing their watched status.
+    If one is completed while the other isn't, choose the completed one.
+    If both are completed or both are not, choose the one with the higher time.
+    """
+    if ep1.status.completed and not ep2.status.completed:
+        return ep1
+    elif ep2.status.completed and not ep1.status.completed:
+        return ep2
+    return ep1 if ep1.status.time >= ep2.status.time else ep2
+
+
+def merge_series_data(series1: Series, series2: Series) -> Series:
+    """
+    Merge two Series objects by combining their episodes.
+    For duplicate episodes (determined by check_same_identifiers), merge their watched status.
+    """
+    merged_series = copy.deepcopy(series1)
+
+    # For each episode in series2, see if there's a matching episode in the merged series.
+    for ep in series2.episodes:
+        found = False
+        for idx, merged_ep in enumerate(merged_series.episodes):
+            if check_same_identifiers(ep.identifiers, merged_ep.identifiers):
+                # Merge the duplicate episodes.
+                merged_series.episodes[idx] = merge_mediaitem_data(merged_ep, ep)
+                found = True
+                break
+        if not found:
+            merged_series.episodes.append(copy.deepcopy(ep))
+    return merged_series
+
+
 def merge_library_data(lib1: LibraryData, lib2: LibraryData) -> LibraryData:
     """
-    Merge two LibraryData objects by extending their movies and series lists.
-    Assumes that the libraries represent the same data.
+    Merge two LibraryData objects by extending movies and merging series.
+    For series, duplicates are determined using check_same_identifiers.
     """
     merged = copy.deepcopy(lib1)
-    merged.movies.extend(lib2.movies)
-    merged.series.extend(lib2.series)
+
+    # Merge movies.
+    for movie in lib2.movies:
+        found = False
+        for idx, merged_movie in enumerate(merged.movies):
+            if check_same_identifiers(movie.identifiers, merged_movie.identifiers):
+                merged.movies[idx] = merge_mediaitem_data(merged_movie, movie)
+                found = True
+                break
+        if not found:
+            merged.movies.append(copy.deepcopy(movie))
+
+    # For series, check for duplicates using check_same_identifiers.
+    for series2 in lib2.series:
+        found = False
+        for idx, series1 in enumerate(merged.series):
+            if check_same_identifiers(series1.identifiers, series2.identifiers):
+                merged.series[idx] = merge_series_data(series1, series2)
+                found = True
+                break
+        if not found:
+            merged.series.append(copy.deepcopy(series2))
+
     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.
+    """
+    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(
     watched_list_1: dict[str, UserData],
     watched_list_2: dict[str, UserData],
@@ -72,22 +144,37 @@ def merge_server_watched(
     merged_watched = copy.deepcopy(watched_list_1)
 
     for user_2 in watched_list_2:
-        user_other = None
-        if user_mapping:
-            user_other = search_mapping(user_mapping, user_2)
-        user_1 = get_other(watched_list_1, user_2, user_other)
+        # Map the user key if a mapping is provided.
+        user_other = user_mapping.get(user_2) if user_mapping else None
+        user_1 = (
+            user_other
+            if user_other in watched_list_1
+            else user_2
+            if user_2 in watched_list_1
+            else None
+        )
 
         if user_1 is None:
+            # Optionally, add the whole new user:
+            merged_watched[user_2] = copy.deepcopy(watched_list_2[user_2])
             continue
 
         for library_2_key in watched_list_2[user_2].libraries:
-            library_other = None
-            if library_mapping:
-                library_other = search_mapping(library_mapping, library_2_key)
-            library_1_key = get_other(
-                watched_list_1[user_1].libraries, library_2_key, library_other
+            library_other = (
+                library_mapping.get(library_2_key) if library_mapping else None
+            )
+            library_1_key = (
+                library_other
+                if library_other in watched_list_1[user_1].libraries
+                else library_2_key
+                if library_2_key in watched_list_1[user_1].libraries
+                else None
             )
             if library_1_key is None:
+                # Optionally, add the new library:
+                merged_watched[user_1].libraries[library_2_key] = copy.deepcopy(
+                    watched_list_2[user_2].libraries[library_2_key]
+                )
                 continue
 
             # Merge the two libraries.