MediaContextHandle

Ручка для взаимодействия с медиа контентом

src/contexts/MediaContext.jsx

@@ -1,117 +1,90 @@
-import { createContext, useContext, useState, useCallback } from "react";
-import {
-  getTrendingMedia,
-  getMediaById,
-  searchMedia,
-} from "../services/mediaService";
+import React, { createContext, useContext, useState } from 'react';
+import { searchMedia, getMediaDetails, validateMediaData, formatMediaData } from '../services/mediaService';
+import { createMedia } from '../services/supabase';
 
 const MediaContext = createContext();
 
-export function useMedia() {
+export const useMedia = () => {
   const context = useContext(MediaContext);
   if (!context) {
-    throw new Error("useMedia must be used within a MediaProvider");
+    throw new Error('useMedia must be used within a MediaProvider');
   }
   return context;
-}
+};
 
-export function MediaProvider({ children }) {
-  const [trendingMovies, setTrendingMovies] = useState([]);
-  const [trendingTvShows, setTrendingTvShows] = useState([]);
-  const [trendingGames, setTrendingGames] = useState([]);
-  const [currentMedia, setCurrentMedia] = useState(null);
+export const MediaProvider = ({ children }) => {
+  const [searchResults, setSearchResults] = useState([]);
+  const [selectedMedia, setSelectedMedia] = useState(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState(null);
-  const [searchResults, setSearchResults] = useState([]);
 
-  const fetchTrendingMedia = useCallback(async () => {
+  const handleSearch = async (query, type = 'movie') => {
+    try {
       setLoading(true);
       setError(null);
-
-    try {
-      const [movies, tvShows, games] = await Promise.all([
-        getTrendingMedia("movie"),
-        getTrendingMedia("tv"),
-        getTrendingMedia("game"),
-      ]);
-
-      setTrendingMovies(movies || []);
-      setTrendingTvShows(tvShows || []);
-      setTrendingGames(games || []);
-    } catch (err) {
-      setError(err.message || "Failed to fetch trending media");
-      console.error("Fetch trending error:", err);
-      // Сброс состояний на случай частичного успеха
-      setTrendingMovies([]);
-      setTrendingTvShows([]);
-      setTrendingGames([]);
+      const results = await searchMedia(query, type);
+      setSearchResults(results);
+    } catch (error) {
+      console.error('Search error:', error);
+      setError('Ошибка при поиске медиа');
     } finally {
       setLoading(false);
     }
-  }, []);
-
-  const fetchMediaDetails = useCallback(async (id) => {
-    if (!id) {
-      setError("Invalid media ID");
-      return;
-    }
+  };
 
+  const handleSelectMedia = async (tmdbId, type) => {
+    try {
       setLoading(true);
       setError(null);
-    setCurrentMedia(null);
-
-    try {
-      const data = await getMediaById(id);
-      if (!data) {
-        throw new Error("Media not found");
-      }
-      setCurrentMedia(data);
-    } catch (err) {
-      setError(err.message || "Failed to fetch media details");
-      console.error("Fetch details error:", err);
+      const details = await getMediaDetails(tmdbId, type);
+      setSelectedMedia(details);
+    } catch (error) {
+      console.error('Error fetching media details:', error);
+      setError('Ошибка при получении деталей медиа');
     } finally {
       setLoading(false);
     }
-  }, []);
-
-  const handleSearch = useCallback(async (query) => {
-    if (!query || !query.trim()) {
-      setSearchResults([]);
-      return;
-    }
+  };
 
+  const handleCreateMedia = async (mediaData) => {
+    try {
       setLoading(true);
       setError(null);
 
-    try {
-      const results = await searchMedia(query);
-      setSearchResults(Array.isArray(results) ? results : []);
-    } catch (err) {
-      setError(err.message || "Search failed");
-      console.error("Search error:", err);
-      setSearchResults([]);
+      // Валидация данных
+      const errors = validateMediaData(mediaData);
+      if (errors.length > 0) {
+        throw new Error(errors.join('\n'));
+      }
+
+      // Форматирование данных
+      const formattedData = formatMediaData(mediaData);
+
+      // Создание медиа
+      const newMedia = await createMedia(formattedData);
+      return newMedia;
+    } catch (error) {
+      console.error('Error creating media:', error);
+      setError(error.message || 'Ошибка при создании медиа');
+      throw error;
     } finally {
       setLoading(false);
     }
-  }, []);
+  };
 
   const value = {
-    trendingMovies,
-    trendingTvShows,
-    trendingGames,
-    currentMedia,
+    searchResults,
+    selectedMedia,
     loading,
     error,
-    searchResults,
-    fetchTrendingMedia,
-    fetchMediaDetails,
     handleSearch,
-    clearError: () => setError(null),
-    clearCurrentMedia: () => setCurrentMedia(null),
-    clearSearchResults: () => setSearchResults([]),
+    handleSelectMedia,
+    handleCreateMedia
   };
 
   return (
-    <MediaContext.Provider value={value}>{children}</MediaContext.Provider>
+    <MediaContext.Provider value={value}>
+      {children}
+    </MediaContext.Provider>
   );
-}
+};