streamyfin/hooks/usePlaybackManager.ts

import { getPlaystateApi } from "@jellyfin/sdk/lib/utils/api";
import { getUserLibraryApi } from "@jellyfin/sdk/lib/utils/api/user-library-api";
import { useNetInfo } from "@react-native-community/netinfo";
import { useAtomValue } from "jotai";
import { useDownload } from "@/providers/DownloadProvider";
import { DownloadedItem } from "@/providers/Downloads/types";
import { apiAtom, userAtom } from "@/providers/JellyfinProvider";

/**
 * A hook to manage playback state, abstracting away the complexities of
 * online/offline and local/remote state management.
 *
 * This provides a simple facade for player components to report playback
 * without needing to know the underlying details of data syncing.
 */
export const usePlaybackManager = () => {
  const api = useAtomValue(apiAtom);
  const user = useAtomValue(userAtom);
  const netInfo = useNetInfo();
  const { getDownloadedItemById, updateDownloadedItem } = useDownload();

  /** Whether the device is online. actually it's connected to the internet. */
  const isOnline = netInfo.isConnected;

  /**
   * Fetches the latest state of an item from the server and updates the local
   * downloaded version to match. This ensures the local item has the
   * canonical state from the server.
   */
  const _syncRemoteToLocal = async (localItem: DownloadedItem) => {
    if (!isOnline || !api || !user) return;

    try {
      const remoteItem = (
        await getUserLibraryApi(api).getItem({
          itemId: localItem.item.Id!,
          userId: user.Id,
        })
      ).data;
      if (remoteItem) {
        updateDownloadedItem(localItem.item.Id!, {
          ...localItem,
          item: {
            ...localItem.item,
            UserData: { ...remoteItem.UserData },
          },
        });
      }
    } catch (error) {
      console.error("Failed to sync remote item state to local", error);
    }
  };

  /**
   * Reports playback progress.
   *
   * - If offline and the item is downloaded, updates are saved locally.
   * - If online and the item is downloaded, it updates locally and syncs with the server.
   * - If online and streaming, it reports directly to the server.
   *
   * @param itemId The ID of the item.
   * @param positionTicks The current playback position in ticks.
   */
  const reportPlaybackProgress = async (
    itemId: string,
    positionTicks: number,
    metadata?: {
      AudioStreamIndex: number;
      SubtitleStreamIndex: number;
    },
  ) => {
    const localItem = getDownloadedItemById(itemId);

    // Handle local state update for downloaded items
    if (localItem) {
      const isItemConsideredPlayed =
        (localItem.item.UserData?.PlayedPercentage ?? 0) > 90;
      updateDownloadedItem(itemId, {
        ...localItem,
        item: {
          ...localItem.item,
          UserData: {
            ...localItem.item.UserData,
            PlaybackPositionTicks: isItemConsideredPlayed ? 0 : positionTicks,
            Played: isItemConsideredPlayed,
            LastPlayedDate: new Date().toISOString(),
            PlayedPercentage: isItemConsideredPlayed
              ? 0
              : (positionTicks / localItem.item.RunTimeTicks!) * 100,
          },
        },
      });
    }

    // Handle remote state update if online
    if (isOnline && api) {
      try {
        await getPlaystateApi(api).reportPlaybackProgress({
          playbackProgressInfo: {
            ItemId: itemId,
            PositionTicks: positionTicks,
            ...(metadata && { AudioStreamIndex: metadata.AudioStreamIndex }),
            ...(metadata && {
              SubtitleStreamIndex: metadata.SubtitleStreamIndex,
            }),
          },
        });
      } catch (error) {
        console.error("Failed to report playback progress on server", error);
      }
      // If it was a downloaded item, re-sync with the server for the latest state.
      // This is crucial because the server might have marked the item as "Played"
      // based on its own rules (e.g., >95% progress).
      if (localItem) {
        await _syncRemoteToLocal(localItem);
      }
    }
  };

  /**
   * Marks an item as played.
   *
   * - If offline and downloaded, it marks as played locally.
   * - If online, it marks as played on the server and syncs the state back to the local item if it exists.
   *
   * @param itemId The ID of the item.
   */
  const markItemPlayed = async (itemId: string) => {
    const localItem = getDownloadedItemById(itemId);

    // Handle local state update for downloaded items
    if (localItem) {
      updateDownloadedItem(itemId, {
        ...localItem,
        item: {
          ...localItem.item,
          UserData: {
            ...localItem.item.UserData,
            Played: true,
            PlaybackPositionTicks: 0,
            PlayedPercentage: 0,
            LastPlayedDate: new Date().toISOString(),
          },
        },
      });
    }

    // Handle remote state update if online
    if (isOnline && api && user) {
      try {
        await getPlaystateApi(api).markPlayedItem({
          itemId,
          userId: user.Id,
        });

        // If it was a downloaded item, re-sync with server for the latest state
        if (localItem) {
          await _syncRemoteToLocal(localItem);
        }
      } catch (error) {
        console.error("Failed to mark item as played on server", error);
      }
    }
  };

  /**
   * Marks an item as unplayed.
   *
   * - If offline and downloaded, it marks as unplayed locally.
   * - If online, it marks as unplayed on the server and syncs the state back to the local item if it exists.
   *
   * @param itemId The ID of the item.
   */
  const markItemUnplayed = async (itemId: string) => {
    const localItem = getDownloadedItemById(itemId);

    // Handle local state update for downloaded items
    if (localItem) {
      updateDownloadedItem(itemId, {
        ...localItem,
        item: {
          ...localItem.item,
          UserData: {
            ...localItem.item.UserData,
            Played: false,
            PlaybackPositionTicks: 0,
            PlayedPercentage: 0,
            LastPlayedDate: new Date().toISOString(), // Keep track of when it was marked unplayed
          },
        },
      });
    }

    // Handle remote state update if online
    if (isOnline && api && user) {
      try {
        await getPlaystateApi(api).markUnplayedItem({
          itemId,
          userId: user.Id,
        });

        // If it was a downloaded item, re-sync with server for the latest state
        if (localItem) {
          await _syncRemoteToLocal(localItem);
        }
      } catch (error) {
        console.error("Failed to mark item as unplayed on server", error);
      }
    }
  };

  return { reportPlaybackProgress, markItemPlayed, markItemUnplayed };
};