@zezosoft/zezo-ott-react-native-ui-kit 1.1.5 → 1.1.6

package/src/components/Content/Card/Sliders/Styles/Three.tsx

@@ -1,935 +0,0 @@
-import {
-  StatusBar,
-  StyleSheet,
-  TouchableOpacity,
-  View,
-  useWindowDimensions,
-  type ViewToken,
-  type AccessibilityProps,
-} from 'react-native';
-import React, {
-  memo,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react';
-import LinearGradient from 'react-native-linear-gradient';
-import { moderateScale, verticalScale } from 'react-native-size-matters';
-import Animated, {
-  Extrapolation,
-  interpolate,
-  useAnimatedScrollHandler,
-  useAnimatedStyle,
-  useSharedValue,
-  type SharedValue,
-} from 'react-native-reanimated';
-import FastImage from 'react-native-fast-image';
-import { ActivityIndicator } from 'react-native';
-import { Play, Plus, CheckCircle2, Info } from 'lucide-react-native';
-import { Text } from '../../../../Text';
-import type { IContentData } from '@zezosoft/zezo-ott-api-client';
-import SkeletonPlaceholder from 'react-native-skeleton-placeholder';
-import type { ISectionContent } from '../../../../../types';
-import type { ITheme, ThemeOverride } from '../../../../../theme/themes';
-import { useInternalTheme } from '../../../../../theme/hook/useInternalTheme';
-
-type SkeletonItem = {
-  _id: string;
-  isSkeleton: true;
-};
-
-const SkeletonGradient = memo<{ theme: ITheme }>(({ theme }) => {
-  const gradients = [
-    {
-      colors: [theme.colors.background, 'rgba(0,0,0,0)'],
-      style: {
-        top: 0,
-        height: verticalScale(SLIDER_HEIGHT) / GRADIENT_DIVIDER_BOTTOM,
-      },
-    },
-    {
-      colors: ['rgba(0,0,0,0)', theme.colors.background],
-      style: { bottom: 0 },
-    },
-  ];
-
-  return (
-    <>
-      {gradients.map((g, i) => (
-        <LinearGradient
-          key={i}
-          colors={g.colors}
-          pointerEvents="none"
-          style={[StyleSheet.absoluteFillObject, g.style]}
-        />
-      ))}
-    </>
-  );
-});
-
-SkeletonGradient.displayName = 'SkeletonGradient';
-
-const S = SkeletonPlaceholder.Item;
-
-const ContentInfoSkeleton = memo<{ theme: ITheme }>(({ theme }) => {
-  const circle = moderateScale(44);
-
-  return (
-    <View
-      style={[
-        styles.contentInfoContainer,
-        { backgroundColor: theme.colors.background },
-      ]}
-    >
-      <SkeletonPlaceholder
-        backgroundColor={theme.colors.skeletonBaseColor}
-        highlightColor={theme.colors.skeletonHighlightColor}
-      >
-        <S
-          width={moderateScale(140)}
-          height={moderateScale(10)}
-          borderRadius={6}
-          alignSelf="center"
-          marginBottom={verticalScale(18)}
-        />
-        <S
-          height={verticalScale(60)}
-          justifyContent="center"
-          alignItems="center"
-        >
-          <S
-            width={circle}
-            height={circle}
-            borderRadius={circle / 2}
-            position="absolute"
-            left={moderateScale(16)}
-          />
-          <S
-            width={moderateScale(140)}
-            height={verticalScale(48)}
-            borderRadius={6}
-          />
-          <S
-            width={circle}
-            height={circle}
-            borderRadius={circle / 2}
-            position="absolute"
-            right={moderateScale(16)}
-          />
-        </S>
-      </SkeletonPlaceholder>
-    </View>
-  );
-});
-
-ContentInfoSkeleton.displayName = 'ContentInfoSkeleton';
-
-const SLIDER_HEIGHT = 370;
-const TITLE_IMAGE_HEIGHT = 55;
-const TITLE_IMAGE_WIDTH_PERCENT = '80%';
-// const SKELETON_COUNT = 1;
-const AUTO_PLAY_INTERVAL = 5000;
-const LOOP_MULTIPLIER = 3;
-const VIEWABILITY_THRESHOLD = 50;
-const GRADIENT_DIVIDER_BOTTOM = 2;
-const GRADIENT_DIVIDER_TOP = 1.1;
-
-type SliderThreeProps = {
-  index?: number;
-  data: ISectionContent | null;
-  onPressItem?: (item: IContentData) => void;
-  isLoading?: boolean;
-  theme?: ThemeOverride;
-  onToggleWatchlist?: (
-    item: IContentData,
-    { isFavorite }: { isFavorite: boolean }
-  ) => void;
-  checkWatchlistStatus?: (
-    itemIds: string[]
-  ) => Record<string, boolean> | Promise<Record<string, boolean>>;
-} & AccessibilityProps;
-
-type BackImageProps = {
-  item: IContentData;
-  index: number;
-  x: SharedValue<number>;
-  theme: ITheme;
-  sliderDataLength: number;
-  width: number;
-};
-
-type GradientProps = {
-  theme: ITheme;
-};
-
-type RenderItemProps = {
-  item: IContentData | SkeletonItem;
-  index: number;
-  x: SharedValue<number>;
-  theme: ITheme;
-};
-
-type ContentInfoProps = {
-  theme: ITheme;
-  item: IContentData;
-  onPressItem?: (item: IContentData) => void;
-  isFavorite?: boolean;
-  onToggleWatchlist?: (
-    item: IContentData,
-    { isFavorite }: { isFavorite: boolean }
-  ) => void;
-};
-
-const SliderThree: React.FC<SliderThreeProps> = ({
-  index = 0,
-  data,
-  onPressItem,
-  isLoading = false,
-  theme,
-  onToggleWatchlist,
-  checkWatchlistStatus,
-  accessibilityLabel = 'Netflix style slider',
-  accessibilityHint = 'Swipe to view content',
-}) => {
-  const { width } = useWindowDimensions();
-  const { theme: appliedTheme } = useInternalTheme(theme);
-  const scrollX = useSharedValue(0);
-  const flatListRef =
-    useRef<Animated.FlatList<IContentData | SkeletonItem>>(null);
-
-  const autoPlayIntervalRef = useRef<NodeJS.Timeout | null>(null);
-  const currentIndexRef = useRef(0);
-  const isDraggingRef = useRef(false);
-  const watchlistCache = useRef<Map<string, boolean>>(new Map());
-  const isCheckingRef = useRef<boolean>(false);
-  const [isInWatchlist, setIsInWatchlist] = useState<boolean>(false);
-  const skeletonItems = useMemo<SkeletonItem[]>(
-    () =>
-      Array.from({ length: 3 }).map((_, i) => ({
-        _id: `skeleton-${i}`,
-        isSkeleton: true,
-      })),
-    []
-  );
-
-  const sliderData = useMemo<(IContentData | SkeletonItem)[]>(() => {
-    if (isLoading) return skeletonItems;
-
-    return (data?.data ?? []).filter(
-      (item): item is IContentData => !('type' in item && item.type === 'ads')
-    );
-  }, [data, isLoading, skeletonItems]);
-
-  const [currentIndex, setCurrentIndex] = useState(0);
-
-  useEffect(() => {
-    if (
-      !checkWatchlistStatus ||
-      sliderData.length === 0 ||
-      isCheckingRef.current
-    ) {
-      return;
-    }
-
-    const itemIds = sliderData
-      .filter((item): item is IContentData => item !== null && !!item._id)
-      .map((item) => item._id);
-
-    if (itemIds.length === 0) {
-      return;
-    }
-
-    const uncachedIds = itemIds.filter((id) => !watchlistCache.current.has(id));
-
-    if (uncachedIds.length === 0) {
-      if (sliderData[currentIndex]?._id) {
-        setIsInWatchlist(
-          watchlistCache.current.get(sliderData[currentIndex]._id) ?? false
-        );
-      }
-      return;
-    }
-
-    isCheckingRef.current = true;
-    (async () => {
-      try {
-        const result = checkWatchlistStatus(uncachedIds);
-        const statusResult = result instanceof Promise ? await result : result;
-        Object.entries(statusResult)?.forEach?.(([itemId, status]) => {
-          watchlistCache.current.set(itemId, status);
-        });
-        if (sliderData[currentIndex]?._id) {
-          setIsInWatchlist(
-            watchlistCache.current.get(sliderData[currentIndex]._id) ?? false
-          );
-        }
-      } catch (error) {
-        console.error('Error checking watchlist status:', error);
-        uncachedIds?.forEach?.((id) => watchlistCache.current.set(id, false));
-        if (sliderData[currentIndex]?._id) {
-          setIsInWatchlist(false);
-        }
-      } finally {
-        isCheckingRef.current = false;
-      }
-    })();
-  }, [sliderData, checkWatchlistStatus, currentIndex]);
-
-  const infiniteData = useMemo(() => {
-    if (!sliderData.length) return [];
-
-    if (isLoading) return sliderData;
-
-    return Array.from({ length: LOOP_MULTIPLIER }).flatMap(() => sliderData);
-  }, [sliderData, isLoading]);
-
-  const initialScrollIndex = useMemo(
-    () => (isLoading ? 0 : sliderData.length),
-    [isLoading, sliderData.length]
-  );
-
-  const [autoPlay, setAutoPlay] = useState(true);
-
-  const normalizeIndex = useCallback(
-    (idx: number) => (sliderData.length ? idx % sliderData.length : 0),
-    [sliderData.length]
-  );
-
-  const resetToMiddleSection = useCallback(() => {
-    const totalItems = sliderData.length;
-    const rawIndex = currentIndexRef.current;
-    const maxIndex = infiniteData.length - 1;
-
-    if (rawIndex < totalItems || rawIndex >= totalItems * 2) {
-      const middleIndex = totalItems + normalizeIndex(rawIndex);
-      if (middleIndex >= 0 && middleIndex <= maxIndex && flatListRef.current) {
-        flatListRef.current.scrollToIndex({
-          index: middleIndex,
-          animated: false,
-        });
-        currentIndexRef.current = middleIndex;
-      }
-    }
-  }, [sliderData.length, normalizeIndex, infiniteData.length]);
-
-  const onViewableItemsChangedRef = useRef<
-    ({ viewableItems }: { viewableItems: ViewToken[] }) => void
-  >(() => {});
-
-  const onViewableItemsChanged = useCallback(
-    ({ viewableItems }: { viewableItems: ViewToken[] }) => {
-      if (!viewableItems.length) return;
-
-      const rawIndex = viewableItems[0]?.index ?? 0;
-      currentIndexRef.current = rawIndex;
-      setCurrentIndex(normalizeIndex(rawIndex));
-    },
-    [normalizeIndex]
-  );
-
-  useEffect(() => {
-    onViewableItemsChangedRef.current = onViewableItemsChanged;
-  }, [onViewableItemsChanged]);
-
-  const stableOnViewableItemsChanged = useCallback(
-    ({ viewableItems }: { viewableItems: ViewToken[] }) => {
-      onViewableItemsChangedRef.current?.({ viewableItems });
-    },
-    []
-  );
-
-  const viewabilityConfigCallbackPairs = useRef([
-    {
-      viewabilityConfig: {
-        itemVisiblePercentThreshold: VIEWABILITY_THRESHOLD,
-        waitForInteraction: false,
-      },
-      onViewableItemsChanged: stableOnViewableItemsChanged,
-    },
-  ]);
-
-  const onScroll = useAnimatedScrollHandler({
-    onScroll: (event) => {
-      scrollX.value = event.contentOffset.x;
-    },
-  });
-
-  const handleScrollBeginDrag = useCallback(() => {
-    setAutoPlay(false);
-    isDraggingRef.current = true;
-  }, []);
-
-  const handleMomentumScrollEnd = useCallback(() => {
-    isDraggingRef.current = false;
-    resetToMiddleSection();
-    setAutoPlay(true);
-  }, [resetToMiddleSection]);
-  const handleToggleWatchlist = useCallback(
-    async (item: IContentData, { isFavorite }: { isFavorite: boolean }) => {
-      if (!item._id) return;
-
-      const newStatus = !isFavorite;
-      setIsInWatchlist(newStatus);
-      watchlistCache.current.set(item._id, newStatus);
-
-      try {
-        if (onToggleWatchlist) {
-          await onToggleWatchlist(item, { isFavorite });
-        }
-      } catch (error) {
-        console.error('Error toggling watchlist:', error);
-        const revertedStatus = isFavorite;
-        setIsInWatchlist(revertedStatus);
-        watchlistCache.current.set(item._id, revertedStatus);
-      }
-    },
-    [onToggleWatchlist]
-  );
-
-  // Initial sync (scrollX, currentIndexRef) + debounced currentIndex; single effect to limit useEffect count
-  useEffect(() => {
-    if (sliderData.length > 0) {
-      currentIndexRef.current = initialScrollIndex;
-      if (!isLoading && width > 0) scrollX.value = initialScrollIndex * width;
-    }
-    if (!sliderData.length) return;
-    const t = setTimeout(
-      () => setCurrentIndex(normalizeIndex(currentIndexRef.current)),
-      150
-    );
-    return () => clearTimeout(t);
-  }, [
-    sliderData.length,
-    initialScrollIndex,
-    isLoading,
-    width,
-    normalizeIndex,
-    scrollX,
-  ]);
-
-  useEffect(() => {
-    onViewableItemsChangedRef.current = onViewableItemsChanged;
-  }, [onViewableItemsChanged]);
-
-  // Auto-play interval + deferred image preload (single effect to limit useEffect count)
-  useEffect(() => {
-    if (isLoading || sliderData.length === 0) return;
-
-    const preloadId = setTimeout(() => {
-      const uris: string[] = [];
-      const indices = [
-        currentIndex,
-        (currentIndex - 1 + sliderData.length) % sliderData.length,
-        (currentIndex + 1) % sliderData.length,
-      ];
-      for (const i of indices) {
-        const slideItem = sliderData[i];
-        if (slideItem && !('isSkeleton' in slideItem)) {
-          const poster = slideItem.poster?.trim?.();
-          if (poster?.length) uris.push(poster);
-          const title = slideItem.title_image?.trim?.();
-          if (title?.length) uris.push(title);
-        }
-      }
-      if (uris.length > 0) FastImage.preload(uris.map((uri) => ({ uri })));
-    }, 0);
-
-    if (!autoPlay || sliderData.length <= 1) {
-      return () => clearTimeout(preloadId);
-    }
-    autoPlayIntervalRef.current = setInterval(() => {
-      if (!isDraggingRef.current && flatListRef.current) {
-        const nextIndex = currentIndexRef.current + 1;
-        const maxIndex = infiniteData.length - 1;
-        if (nextIndex >= 0 && nextIndex <= maxIndex) {
-          flatListRef.current.scrollToIndex({
-            index: nextIndex,
-            animated: true,
-          });
-        }
-      }
-    }, AUTO_PLAY_INTERVAL);
-    return () => {
-      clearTimeout(preloadId);
-      if (autoPlayIntervalRef.current) {
-        clearInterval(autoPlayIntervalRef.current);
-      }
-    };
-  }, [
-    autoPlay,
-    sliderData.length,
-    infiniteData.length,
-    currentIndex,
-    sliderData,
-    isLoading,
-  ]);
-
-  const renderItem = useCallback(
-    ({
-      item: listItem,
-      index: itemIndex,
-    }: {
-      item: IContentData | SkeletonItem;
-      index: number;
-    }) => (
-      <RenderItem
-        item={listItem}
-        index={itemIndex}
-        x={scrollX}
-        theme={appliedTheme}
-      />
-    ),
-    [scrollX, appliedTheme]
-  );
-
-  const keyExtractor = useCallback(
-    (listItem: IContentData | SkeletonItem, i: number) =>
-      `item-${listItem._id ?? i}-${i}`,
-    []
-  );
-
-  const getItemLayout = useCallback(
-    (
-      _: ArrayLike<IContentData | SkeletonItem> | null | undefined,
-      i: number
-    ) => ({
-      length: width,
-      offset: width * i,
-      index: i,
-    }),
-    [width]
-  );
-
-  const backImageList = useMemo(() => {
-    if (isLoading) return null;
-    return sliderData.map((item, i) => (
-      <BackImage
-        key={`bg-${i}-${index}`}
-        item={item as IContentData}
-        index={i}
-        x={scrollX}
-        theme={appliedTheme}
-        sliderDataLength={sliderData.length}
-        width={width}
-      />
-    ));
-  }, [isLoading, sliderData, index, scrollX, appliedTheme, width]);
-
-  if (!data) {
-    return null;
-  }
-
-  return (
-    <View
-      style={styles.container}
-      accessibilityLabel={accessibilityLabel}
-      accessibilityHint={accessibilityHint}
-    >
-      <StatusBar translucent backgroundColor="transparent" />
-
-      {backImageList}
-
-      <Gradient theme={appliedTheme} />
-
-      <Animated.FlatList
-        ref={flatListRef}
-        data={infiniteData}
-        horizontal
-        pagingEnabled
-        bounces={false}
-        showsHorizontalScrollIndicator={false}
-        initialScrollIndex={initialScrollIndex}
-        getItemLayout={getItemLayout}
-        onScroll={onScroll}
-        scrollEventThrottle={16}
-        viewabilityConfigCallbackPairs={viewabilityConfigCallbackPairs.current}
-        onScrollBeginDrag={handleScrollBeginDrag}
-        onMomentumScrollEnd={handleMomentumScrollEnd}
-        renderItem={renderItem}
-        keyExtractor={keyExtractor}
-        removeClippedSubviews={true}
-        maxToRenderPerBatch={5}
-        windowSize={5}
-        initialNumToRender={3}
-        updateCellsBatchingPeriod={100}
-      />
-
-      {isLoading ? (
-        <ContentInfoSkeleton theme={appliedTheme} />
-      ) : (
-        sliderData[currentIndex] &&
-        !('isSkeleton' in sliderData[currentIndex]) && (
-          <ContentInfo
-            theme={appliedTheme}
-            item={sliderData[currentIndex]}
-            onPressItem={onPressItem}
-            isFavorite={isInWatchlist}
-            onToggleWatchlist={handleToggleWatchlist}
-          />
-        )
-      )}
-    </View>
-  );
-};
-
-export default memo(SliderThree);
-
-const BackImage = memo<BackImageProps>(
-  ({ item, index, x, theme, sliderDataLength, width }) => {
-    const [loadError, setLoadError] = useState(false);
-    const posterUri = item.poster?.trim?.() ?? '';
-    const hasValidUri = posterUri.length > 0;
-    const prevPosterUriRef = useRef(posterUri);
-
-    const handleLoad = useCallback(() => setLoadError(false), []);
-    const handleError = useCallback(() => setLoadError(true), []);
-
-    // Reset error when URI changes; retry once after load error (transient failures)
-    useEffect(() => {
-      if (prevPosterUriRef.current !== posterUri) {
-        prevPosterUriRef.current = posterUri;
-        setLoadError(false);
-      }
-      if (!loadError || !hasValidUri) return;
-      const id = setTimeout(() => setLoadError(false), 1000);
-      return () => clearTimeout(id);
-    }, [posterUri, loadError, hasValidUri]);
-
-    const animatedStyle = useAnimatedStyle(() => {
-      'worklet';
-      const totalWidth = sliderDataLength * width;
-      if (totalWidth <= 0 || width <= 0) {
-        return { opacity: index === 0 ? 1 : 0 };
-      }
-      const scrollInWidth = ((x.value % totalWidth) + totalWidth) % totalWidth;
-      const normalizedScroll = scrollInWidth / width - 1;
-      const distance = Math.abs(normalizedScroll - index);
-      if (distance < 0.01) return { opacity: 1 };
-      const raw = distance <= 1 ? 1 - distance : 0;
-      const opacity = Math.min(1, Math.max(0, raw));
-      return { opacity };
-    });
-
-    return (
-      <Animated.View
-        style={[
-          StyleSheet.absoluteFillObject,
-          {
-            width,
-            height: verticalScale(SLIDER_HEIGHT),
-          },
-          animatedStyle,
-        ]}
-      >
-        {hasValidUri && !loadError && (
-          <FastImage
-            key={`poster-${item._id}-${posterUri}`}
-            source={{
-              uri: posterUri,
-              priority: FastImage.priority.normal,
-              cache: FastImage.cacheControl.immutable,
-            }}
-            style={[
-              StyleSheet.absoluteFillObject,
-              {
-                width,
-                height: verticalScale(SLIDER_HEIGHT),
-                backgroundColor: theme.colors.black,
-              },
-            ]}
-            resizeMode={FastImage.resizeMode.cover}
-            onLoad={handleLoad}
-            onError={handleError}
-          />
-        )}
-        {(!hasValidUri || loadError) && (
-          <View
-            style={[
-              StyleSheet.absoluteFillObject,
-              {
-                width,
-                height: verticalScale(SLIDER_HEIGHT),
-                backgroundColor: theme.colors.black,
-              },
-            ]}
-          />
-        )}
-      </Animated.View>
-    );
-  }
-);
-
-BackImage.displayName = 'BackImage';
-
-const Gradient = memo<GradientProps>(({ theme }) => {
-  const { width } = useWindowDimensions();
-
-  return (
-    <View
-      pointerEvents="none"
-      style={[
-        styles.gradientContainer,
-        { width, height: verticalScale(SLIDER_HEIGHT) },
-      ]}
-    >
-      <LinearGradient
-        colors={[theme.colors.background, 'rgba(0,0,0,0)']}
-        style={styles.gradientBottom}
-        pointerEvents="none"
-      />
-      <LinearGradient
-        colors={['rgba(0,0,0,0)', theme.colors.background]}
-        style={styles.gradientTop}
-        pointerEvents="none"
-      />
-    </View>
-  );
-});
-
-Gradient.displayName = 'Gradient';
-
-const RenderItem = memo<RenderItemProps>(({ item, index, x, theme }) => {
-  const { width } = useWindowDimensions();
-  const titleUri =
-    'isSkeleton' in item ? '' : (item.title_image?.trim?.() ?? '');
-  const hasTitleUri = titleUri.length > 0;
-  const [titleLoadError, setTitleLoadError] = useState(false);
-
-  useEffect(() => {
-    setTitleLoadError(false);
-  }, [titleUri]);
-
-  const handleTitleLoad = useCallback(() => setTitleLoadError(false), []);
-  const handleTitleError = useCallback(() => setTitleLoadError(true), []);
-
-  const animatedStyle = useAnimatedStyle(() => ({
-    opacity: interpolate(
-      x.value,
-      [(index - 1) * width, index * width, (index + 1) * width],
-      [-0.5, 1, -0.5],
-      Extrapolation.CLAMP
-    ),
-  }));
-
-  if ('isSkeleton' in item) {
-    return (
-      <View
-        style={{
-          width,
-          height: verticalScale(SLIDER_HEIGHT),
-          position: 'relative',
-          overflow: 'hidden',
-        }}
-      >
-        <SkeletonPlaceholder
-          backgroundColor={theme.colors.skeletonBaseColor}
-          highlightColor={theme.colors.skeletonHighlightColor}
-        >
-          <SkeletonPlaceholder.Item
-            width={width}
-            height={verticalScale(SLIDER_HEIGHT)}
-          />
-        </SkeletonPlaceholder>
-
-        <SkeletonGradient theme={theme} />
-      </View>
-    );
-  }
-
-  return (
-    <View style={{ width, height: verticalScale(SLIDER_HEIGHT) }}>
-      {hasTitleUri && !titleLoadError && (
-        <Animated.View style={[styles.titleImage, animatedStyle]}>
-          <FastImage
-            key={`title-${item._id}-${titleUri}`}
-            source={{
-              uri: titleUri,
-              priority: FastImage.priority.normal,
-              cache: FastImage.cacheControl.immutable,
-            }}
-            style={{ width: '100%', height: '100%' }}
-            resizeMode={FastImage.resizeMode.contain}
-            onLoad={handleTitleLoad}
-            onError={handleTitleError}
-          />
-        </Animated.View>
-      )}
-    </View>
-  );
-});
-
-RenderItem.displayName = 'RenderItem';
-
-const ContentInfo = memo<ContentInfoProps>(
-  ({ theme, item, onPressItem, isFavorite = false, onToggleWatchlist }) => {
-    const [isWatchlistLoading, setIsWatchlistLoading] =
-      useState<boolean>(false);
-    const handleWatchlistPress = useCallback(async () => {
-      if (!item._id) return;
-
-      setIsWatchlistLoading(true);
-
-      try {
-        await onToggleWatchlist?.(item, { isFavorite });
-      } catch (error) {
-        console.error('Error toggling watchlist:', error);
-      } finally {
-        setIsWatchlistLoading(false);
-      }
-    }, [item, isFavorite, onToggleWatchlist]);
-    const handlePlayPress = useCallback(() => {
-      onPressItem?.(item);
-    }, [item, onPressItem]);
-
-    const handleInfoPress = useCallback(() => {
-      onPressItem?.(item);
-    }, [item, onPressItem]);
-
-    const genresText = useMemo(
-      () => item.genres?.map((g) => g.name).join(' • ') ?? '',
-      [item.genres]
-    );
-
-    return (
-      <View
-        style={[
-          styles.contentInfoContainer,
-          { backgroundColor: theme.colors.background },
-        ]}
-      >
-        {genresText ? (
-          <Text style={[styles.genreText, { color: theme.colors.white }]}>
-            {genresText}
-          </Text>
-        ) : null}
-
-        <View style={styles.btnContainer}>
-          <TouchableOpacity
-            style={styles.mylistBtn}
-            onPress={handleWatchlistPress}
-            accessibilityRole="button"
-            accessibilityLabel={
-              isFavorite ? 'Remove from My List' : 'Add to My List'
-            }
-          >
-            {isWatchlistLoading ? (
-              <ActivityIndicator color={theme.colors.textPrimary} />
-            ) : isFavorite ? (
-              <CheckCircle2 size={22} color={theme.colors.textPrimary} />
-            ) : (
-              <Plus size={22} color={theme.colors.textPrimary} />
-            )}
-            <Text style={{ color: theme.colors.textPrimary }}>My List</Text>
-          </TouchableOpacity>
-
-          <TouchableOpacity
-            style={[styles.playBtn, { backgroundColor: theme.colors.button }]}
-            onPress={handlePlayPress}
-            accessibilityRole="button"
-            accessibilityLabel="Play content"
-          >
-            <Play size={20} color={theme.colors.buttonText} />
-            <Text style={[styles.playText, { color: theme.colors.buttonText }]}>
-              Play
-            </Text>
-          </TouchableOpacity>
-
-          <TouchableOpacity
-            style={styles.infoBtn}
-            onPress={handleInfoPress}
-            activeOpacity={0.8}
-            accessibilityRole="button"
-            accessibilityLabel="View content information"
-          >
-            <Info size={22} color={theme.colors.textPrimary} />
-            <Text style={{ color: theme.colors.textPrimary }}>Info</Text>
-          </TouchableOpacity>
-        </View>
-      </View>
-    );
-  }
-);
-
-ContentInfo.displayName = 'ContentInfo';
-
-const styles = StyleSheet.create({
-  container: {
-    flex: 1,
-  },
-  gradientContainer: {
-    ...StyleSheet.absoluteFillObject,
-  },
-  gradientBottom: {
-    position: 'absolute',
-    top: 0,
-    height: verticalScale(SLIDER_HEIGHT) / GRADIENT_DIVIDER_BOTTOM,
-    width: '100%',
-  },
-  gradientTop: {
-    position: 'absolute',
-    bottom: 0,
-    height: verticalScale(SLIDER_HEIGHT) / GRADIENT_DIVIDER_TOP,
-    width: '100%',
-  },
-  titleImage: {
-    position: 'absolute',
-    bottom: 0,
-    height: verticalScale(TITLE_IMAGE_HEIGHT),
-    width: TITLE_IMAGE_WIDTH_PERCENT,
-    alignSelf: 'center',
-  },
-  contentInfoContainer: {
-    paddingHorizontal: moderateScale(16),
-    paddingTop: moderateScale(12),
-    paddingBottom: verticalScale(15),
-  },
-  genreText: {
-    fontSize: moderateScale(12),
-    textAlign: 'center',
-    marginBottom: verticalScale(16),
-  },
-  btnContainer: {
-    flexDirection: 'row',
-    justifyContent: 'center',
-    alignItems: 'center',
-    position: 'relative',
-    minHeight: verticalScale(50),
-    paddingVertical: verticalScale(4),
-  },
-  mylistBtn: {
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: verticalScale(6),
-    position: 'absolute',
-    left: moderateScale(16),
-    paddingVertical: verticalScale(8),
-    paddingHorizontal: moderateScale(4),
-  },
-  playBtn: {
-    flexDirection: 'row',
-    alignItems: 'center',
-    justifyContent: 'center',
-    backgroundColor: '#fff',
-    paddingHorizontal: moderateScale(28),
-    paddingVertical: verticalScale(10),
-    borderRadius: 4,
-    gap: moderateScale(8),
-    minWidth: moderateScale(90),
-  },
-  playText: {
-    color: '#000',
-    fontSize: moderateScale(18),
-    fontWeight: '600',
-  },
-  infoBtn: {
-    alignItems: 'center',
-    justifyContent: 'center',
-    gap: verticalScale(6),
-    position: 'absolute',
-    right: moderateScale(16),
-    paddingVertical: verticalScale(8),
-    paddingHorizontal: moderateScale(4),
-  },
-});