chore: add binary to gitignore

Problem:
- MultiSearch endpoint was reading 'language' parameter only
- Frontend sends 'lang' parameter (from interceptor)
- Search results were always in Russian

Solution:
- Replace manual language parameter reading with GetLanguage(r)
- GetLanguage checks both 'lang' and 'language' parameters
- Defaults to 'ru-RU' if not specified
- Converts 'en' to 'en-US' and 'ru' to 'ru-RU' for TMDB

Before:
language := r.URL.Query().Get("language")
if language == "" {
    language = "ru-RU"
}

After:
language := GetLanguage(r)

Result:
✅ Search results now respect ?lang=en parameter
✅ Movie/TV titles in search are localized
✅ Consistent with other endpoints (movies, tv, etc.)

.gitignore

@@ -3,3 +3,11 @@
 node_modules
 package-lock.json
 yarn.lock
+# Binaries
+bin/
+main
+*.exe
+*.dll
+*.so
+*.dylib
+neomovies-api

api/index.go

@@ -97,6 +97,13 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	api.HandleFunc("/players/alloha/{imdb_id}", playersHandler.GetAllohaPlayer).Methods("GET")
 	api.HandleFunc("/players/lumex/{imdb_id}", playersHandler.GetLumexPlayer).Methods("GET")
 	api.HandleFunc("/players/vibix/{imdb_id}", playersHandler.GetVibixPlayer).Methods("GET")
+	api.HandleFunc("/players/vidsrc/{media_type}/{imdb_id}", playersHandler.GetVidsrcPlayer).Methods("GET")
+	api.HandleFunc("/players/vidlink/movie/{imdb_id}", playersHandler.GetVidlinkMoviePlayer).Methods("GET")
+	api.HandleFunc("/players/vidlink/tv/{tmdb_id}", playersHandler.GetVidlinkTVPlayer).Methods("GET")
+	api.HandleFunc("/players/rgshows/{tmdb_id}", playersHandler.GetRgShowsPlayer).Methods("GET")
+	api.HandleFunc("/players/rgshows/{tmdb_id}/{season}/{episode}", playersHandler.GetRgShowsTVPlayer).Methods("GET")
+	api.HandleFunc("/players/iframevideo/{kinopoisk_id}/{imdb_id}", playersHandler.GetIframeVideoPlayer).Methods("GET")
+	api.HandleFunc("/stream/{provider}/{tmdb_id}", playersHandler.GetStreamAPI).Methods("GET")
 
 	api.HandleFunc("/torrents/search/{imdbId}", torrentsHandler.SearchTorrents).Methods("GET")
 	api.HandleFunc("/torrents/movies", torrentsHandler.SearchMovies).Methods("GET")
@@ -146,12 +153,30 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	protected.HandleFunc("/reactions/{mediaType}/{mediaId}", reactionsHandler.RemoveReaction).Methods("DELETE")
 	protected.HandleFunc("/reactions/my", reactionsHandler.GetMyReactions).Methods("GET")
 
+	// CORS configuration - allow all origins
 	corsHandler := handlers.CORS(
-		handlers.AllowedOrigins([]string{"*"}),
+		handlers.AllowedOrigins([]string{
-		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}),
+			"*", // Allow all origins
-		handlers.AllowedHeaders([]string{"Authorization", "Content-Type", "Accept", "Origin", "X-Requested-With", "X-CSRF-Token"}),
+		}),
-		handlers.AllowCredentials(),
+		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "HEAD"}),
-		handlers.ExposedHeaders([]string{"Authorization", "Content-Type"}),
+		handlers.AllowedHeaders([]string{
+			"Authorization",
+			"Content-Type",
+			"Accept",
+			"Origin",
+			"X-Requested-With",
+			"X-CSRF-Token",
+			"Access-Control-Allow-Origin",
+			"Access-Control-Allow-Headers",
+			"Access-Control-Allow-Methods",
+			"Access-Control-Allow-Credentials",
+		}),
+		handlers.ExposedHeaders([]string{
+			"Authorization",
+			"Content-Type",
+			"X-Total-Count",
+		}),
+		handlers.MaxAge(3600),
 	)
 
 	corsHandler(router).ServeHTTP(w, r)

main.go

@@ -78,6 +78,9 @@ func main() {
 	api.HandleFunc("/players/alloha/{imdb_id}", playersHandler.GetAllohaPlayer).Methods("GET")
 	api.HandleFunc("/players/lumex/{imdb_id}", playersHandler.GetLumexPlayer).Methods("GET")
 	api.HandleFunc("/players/vibix/{imdb_id}", playersHandler.GetVibixPlayer).Methods("GET")
+	api.HandleFunc("/players/vidsrc/{media_type}/{imdb_id}", playersHandler.GetVidsrcPlayer).Methods("GET")
+	api.HandleFunc("/players/vidlink/movie/{imdb_id}", playersHandler.GetVidlinkMoviePlayer).Methods("GET")
+	api.HandleFunc("/players/vidlink/tv/{tmdb_id}", playersHandler.GetVidlinkTVPlayer).Methods("GET")
 
 	api.HandleFunc("/torrents/search/{imdbId}", torrentsHandler.SearchTorrents).Methods("GET")
 	api.HandleFunc("/torrents/movies", torrentsHandler.SearchMovies).Methods("GET")
@@ -129,12 +132,30 @@ func main() {
 	protected.HandleFunc("/reactions/{mediaType}/{mediaId}", reactionsHandler.RemoveReaction).Methods("DELETE")
 	protected.HandleFunc("/reactions/my", reactionsHandler.GetMyReactions).Methods("GET")
 
+	// CORS configuration - allow all origins
 	corsHandler := handlers.CORS(
-		handlers.AllowedOrigins([]string{"*"}),
+		handlers.AllowedOrigins([]string{
-		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "DELETE", "OPTIONS"}),
+			"*", // Allow all origins
-		handlers.AllowedHeaders([]string{"Authorization", "Content-Type", "Accept", "Origin", "X-Requested-With", "X-CSRF-Token"}),
+		}),
-		handlers.AllowCredentials(),
+		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "HEAD"}),
-		handlers.ExposedHeaders([]string{"Authorization", "Content-Type"}),
+		handlers.AllowedHeaders([]string{
+			"Authorization",
+			"Content-Type",
+			"Accept",
+			"Origin",
+			"X-Requested-With",
+			"X-CSRF-Token",
+			"Access-Control-Allow-Origin",
+			"Access-Control-Allow-Headers",
+			"Access-Control-Allow-Methods",
+			"Access-Control-Allow-Credentials",
+		}),
+		handlers.ExposedHeaders([]string{
+			"Authorization",
+			"Content-Type",
+			"X-Total-Count",
+		}),
+		handlers.MaxAge(3600),
 	)
 
 	var finalHandler http.Handler

pkg/handlers/docs.go

@@ -327,123 +327,278 @@ func getOpenAPISpecWithURL(baseURL string) *OpenAPISpec {
 					},
 				},
 			},
-			"/api/v1/players/lumex/{imdb_id}": map[string]interface{}{
+		"/api/v1/players/lumex/{imdb_id}": map[string]interface{}{
-				"get": map[string]interface{}{
+			"get": map[string]interface{}{
-					"summary":     "Плеер Lumex",
+				"summary":     "Плеер Lumex",
-					"description": "Получение плеера Lumex по IMDb ID",
+				"description": "Получение плеера Lumex по IMDb ID. Не поддерживает выбор сезона/серии - плеер работает напрямую с IMDb ID",
-					"tags":        []string{"Players"},
+				"tags":        []string{"Players"},
-					"parameters": []map[string]interface{}{
+				"parameters": []map[string]interface{}{
-						{
+					{
-							"name":        "imdb_id",
+						"name":        "imdb_id",
-							"in":          "path",
+						"in":          "path",
-							"required":    true,
+						"required":    true,
-							"schema":      map[string]string{"type": "string"},
+						"schema":      map[string]string{"type": "string"},
-							"description": "IMDb ID фильма",
+						"description": "IMDb ID фильма или сериала (например, tt0133093)",
-						},
 					},
-					"responses": map[string]interface{}{
+				},
-						"200": map[string]interface{}{
+				"responses": map[string]interface{}{
-							"description": "Данные плеера",
+					"200": map[string]interface{}{
+						"description": "HTML со встроенным Lumex плеером",
+						"content": map[string]interface{}{
+							"text/html": map[string]interface{}{},
 						},
 					},
 				},
 			},
-			"/api/v1/players/vibix/{imdb_id}": map[string]interface{}{
+		},
+		"/api/v1/players/vibix/{imdb_id}": map[string]interface{}{
+			"get": map[string]interface{}{
+				"summary":     "Vibix плеер по IMDb ID",
+				"description": "Возвращает HTML-страницу с iframe Vibix для указанного IMDb ID. Не поддерживает выбор сезона/серии - плеер работает напрямую с IMDb ID",
+				"tags":        []string{"Players"},
+				"parameters": []map[string]interface{}{
+					{
+						"name":        "imdb_id",
+						"in":          "path",
+						"required":    true,
+						"schema":      map[string]string{"type": "string"},
+						"description": "IMDb ID, например tt0133093",
+					},
+				},
+				"responses": map[string]interface{}{
+					"200": map[string]interface{}{
+						"description": "HTML со встроенным Vibix плеером",
+						"content": map[string]interface{}{
+							"text/html": map[string]interface{}{},
+						},
+					},
+					"404": map[string]interface{}{"description": "Фильм не найден"},
+					"503": map[string]interface{}{"description": "VIBIX_TOKEN не настроен"},
+				},
+			},
+		},
+		"/api/v1/players/vidsrc/{media_type}/{imdb_id}": map[string]interface{}{
 				"get": map[string]interface{}{
-					"summary":     "Vibix плеер по IMDb ID",
+					"summary":     "Vidsrc плеер (английский)",
-					"description": "Возвращает HTML-страницу с iframe Vibix для указанного IMDb ID",
+					"description": "Возвращает HTML-страницу с iframe Vidsrc.to. Использует IMDb ID для фильмов и сериалов. Пример URL для фильма: https://vidsrc.to/embed/movie/tt1234567, для сериала: https://vidsrc.to/embed/tv/tt6385540/1/1",
 					"tags":        []string{"Players"},
 					"parameters": []map[string]interface{}{
+						{
+							"name":        "media_type",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]interface{}{"type": "string", "enum": []string{"movie", "tv"}},
+							"description": "Тип контента: movie (фильм) или tv (сериал)",
+						},
 						{
 							"name":        "imdb_id",
 							"in":          "path",
 							"required":    true,
 							"schema":      map[string]string{"type": "string"},
-							"description": "IMDb ID, например tt0133093",
+							"description": "IMDb ID, например tt6385540 (с префиксом tt)",
+						},
+						{
+							"name":        "season",
+							"in":          "query",
+							"required":    false,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер сезона (обязательно для TV)",
+						},
+						{
+							"name":        "episode",
+							"in":          "query",
+							"required":    false,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер серии (обязательно для TV)",
 						},
 					},
 					"responses": map[string]interface{}{
 						"200": map[string]interface{}{
-							"description": "HTML со встроенным Vibix плеером",
+							"description": "HTML со встроенным Vidsrc плеером",
 							"content": map[string]interface{}{
 								"text/html": map[string]interface{}{},
 							},
 						},
-						"404": map[string]interface{}{"description": "Фильм не найден"},
+						"400": map[string]interface{}{"description": "Отсутствуют обязательные параметры"},
-						"503": map[string]interface{}{"description": "VIBIX_TOKEN не настроен"},
 					},
 				},
 			},
-			"/api/v1/webtorrent/player": map[string]interface{}{
+			"/api/v1/players/vidlink/movie/{imdb_id}": map[string]interface{}{
 				"get": map[string]interface{}{
-					"summary":     "WebTorrent плеер",
+					"summary":     "Vidlink плеер для фильмов (английский)",
-					"description": "Открытие WebTorrent плеера с магнет ссылкой. Плеер работает полностью на стороне клиента.",
+					"description": "Возвращает HTML-страницу с iframe Vidlink.pro для фильмов. Использует IMDb ID. Пример URL: https://vidlink.pro/movie/tt1234567",
-					"tags":        []string{"WebTorrent"},
+					"tags":        []string{"Players"},
 					"parameters": []map[string]interface{}{
 						{
-							"name":        "magnet",
+							"name":        "imdb_id",
-							"in":          "query",
+							"in":          "path",
-							"required":    false,
-							"schema":      map[string]string{"type": "string"},
-							"description": "Магнет ссылка торрента",
-						},
-						{
-							"name":        "X-Magnet-Link",
-							"in":          "header",
-							"required":    false,
-							"schema":      map[string]string{"type": "string"},
-							"description": "Магнет ссылка через заголовок (альтернативный способ)",
-						},
-					},
-					"responses": map[string]interface{}{
-						"200": map[string]interface{}{
-							"description": "HTML страница с WebTorrent плеером",
-							"content": map[string]interface{}{
-								"text/html": map[string]interface{}{
-									"schema": map[string]string{"type": "string"},
-								},
-							},
-						},
-						"400": map[string]interface{}{
-							"description": "Отсутствует магнет ссылка",
-						},
-					},
-				},
-			},
-			"/api/v1/webtorrent/metadata": map[string]interface{}{
-				"get": map[string]interface{}{
-					"summary":     "Метаданные медиа",
-					"description": "Получение метаданных фильма или сериала по названию для WebTorrent плеера",
-					"tags":        []string{"WebTorrent"},
-					"parameters": []map[string]interface{}{
-						{
-							"name":        "query",
-							"in":          "query",
 							"required":    true,
 							"schema":      map[string]string{"type": "string"},
-							"description": "Название для поиска (извлеченное из торрента)",
+							"description": "IMDb ID фильма, например tt1234567 (с префиксом tt)",
 						},
 					},
 					"responses": map[string]interface{}{
 						"200": map[string]interface{}{
-							"description": "Метаданные найдены",
+							"description": "HTML со встроенным Vidlink плеером",
 							"content": map[string]interface{}{
-								"application/json": map[string]interface{}{
+								"text/html": map[string]interface{}{},
-									"schema": map[string]interface{}{
-										"$ref": "#/components/schemas/WebTorrentMetadata",
-									},
-								},
 							},
 						},
-						"400": map[string]interface{}{
+						"400": map[string]interface{}{"description": "IMDb ID не указан"},
-							"description": "Отсутствует параметр query",
-						},
-						"404": map[string]interface{}{
-							"description": "Метаданные не найдены",
-						},
 					},
 				},
 			},
+			"/api/v1/players/vidlink/tv/{tmdb_id}": map[string]interface{}{
+				"get": map[string]interface{}{
+					"summary":     "Vidlink плеер для сериалов (английский)",
+					"description": "Возвращает HTML-страницу с iframe Vidlink.pro для сериалов. Использует TMDB ID (без префикса tt). Пример URL: https://vidlink.pro/tv/94997/1/1",
+					"tags":        []string{"Players"},
+					"parameters": []map[string]interface{}{
+						{
+							"name":        "tmdb_id",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "TMDB ID сериала, например 94997 (числовой идентификатор без префикса)",
+						},
+						{
+							"name":        "season",
+							"in":          "query",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер сезона (обязательно)",
+						},
+						{
+							"name":        "episode",
+							"in":          "query",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер серии (обязательно)",
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "HTML со встроенным Vidlink плеером",
+							"content": map[string]interface{}{
+								"text/html": map[string]interface{}{},
+							},
+						},
+						"400": map[string]interface{}{"description": "Отсутствуют обязательные параметры (tmdb_id, season, episode)"},
+					},
+				},
+			},
+			"/api/v1/players/vidsrc-parse/{media_type}/{imdb_id}": map[string]interface{}{
+				"get": map[string]interface{}{
+					"summary":     "Vidsrc плеер с парсингом (кастомный плеер)",
+					"description": "Возвращает HTML-страницу с кастомным Video.js плеером. Автоматически извлекает m3u8 ссылку из Vidsrc.to через клиентский парсинг в iframe. Использует IMDb ID для фильмов и сериалов.",
+					"tags":        []string{"Players"},
+					"parameters": []map[string]interface{}{
+						{
+							"name":        "media_type",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]interface{}{"type": "string", "enum": []string{"movie", "tv"}},
+							"description": "Тип контента: movie (фильм) или tv (сериал)",
+						},
+						{
+							"name":        "imdb_id",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]string{"type": "string"},
+							"description": "IMDb ID, например tt6385540 (с префиксом tt)",
+						},
+						{
+							"name":        "season",
+							"in":          "query",
+							"required":    false,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер сезона (обязательно для TV)",
+						},
+						{
+							"name":        "episode",
+							"in":          "query",
+							"required":    false,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер серии (обязательно для TV)",
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "HTML с кастомным Video.js плеером и системой парсинга",
+							"content": map[string]interface{}{
+								"text/html": map[string]interface{}{},
+							},
+						},
+						"400": map[string]interface{}{"description": "Отсутствуют обязательные параметры"},
+					},
+				},
+			},
+			"/api/v1/players/vidlink-parse/movie/{imdb_id}": map[string]interface{}{
+				"get": map[string]interface{}{
+					"summary":     "Vidlink плеер с парсингом для фильмов (кастомный)",
+					"description": "Возвращает HTML-страницу с кастомным Video.js плеером. Автоматически извлекает m3u8/mp4 ссылку из Vidlink.pro через клиентский парсинг. Использует IMDb ID для фильмов.",
+					"tags":        []string{"Players"},
+					"parameters": []map[string]interface{}{
+						{
+							"name":        "imdb_id",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]string{"type": "string"},
+							"description": "IMDb ID фильма, например tt1234567 (с префиксом tt)",
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "HTML с кастомным Video.js плеером и системой парсинга",
+							"content": map[string]interface{}{
+								"text/html": map[string]interface{}{},
+							},
+						},
+						"400": map[string]interface{}{"description": "IMDb ID не указан"},
+					},
+				},
+			},
+			"/api/v1/players/vidlink-parse/tv/{tmdb_id}": map[string]interface{}{
+				"get": map[string]interface{}{
+					"summary":     "Vidlink плеер с парсингом для сериалов (кастомный)",
+					"description": "Возвращает HTML-страницу с кастомным Video.js плеером. Автоматически извлекает m3u8/mp4 ссылку из Vidlink.pro через клиентский парсинг. Использует TMDB ID для сериалов.",
+					"tags":        []string{"Players"},
+					"parameters": []map[string]interface{}{
+						{
+							"name":        "tmdb_id",
+							"in":          "path",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "TMDB ID сериала, например 94997 (числовой идентификатор без префикса)",
+						},
+						{
+							"name":        "season",
+							"in":          "query",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер сезона (обязательно)",
+						},
+						{
+							"name":        "episode",
+							"in":          "query",
+							"required":    true,
+							"schema":      map[string]string{"type": "integer"},
+							"description": "Номер серии (обязательно)",
+						},
+					},
+					"responses": map[string]interface{}{
+						"200": map[string]interface{}{
+							"description": "HTML с кастомным Video.js плеером и системой парсинга",
+							"content": map[string]interface{}{
+								"text/html": map[string]interface{}{},
+							},
+						},
+						"400": map[string]interface{}{"description": "Отсутствуют обязательные параметры (tmdb_id, season, episode)"},
+					},
+				},
+			},
+
+
 			"/api/v1/torrents/search/{imdbId}": map[string]interface{}{
 				"get": map[string]interface{}{
 					"summary":     "Поиск торрентов",

pkg/handlers/lang_helper.go

@@ -0,0 +1,35 @@
+package handlers
+
+import (
+	"net/http"
+)
+
+// GetLanguage extracts the lang parameter from request and returns it with default "ru"
+// Supports both "lang" and "language" query parameters
+// Valid values: "ru", "en"
+// Default: "ru"
+func GetLanguage(r *http.Request) string {
+	// Check "lang" parameter first (our new standard)
+	lang := r.URL.Query().Get("lang")
+	
+	// Fall back to "language" for backward compatibility
+	if lang == "" {
+		lang = r.URL.Query().Get("language")
+	}
+	
+	// Default to "ru" if not specified
+	if lang == "" {
+		return "ru-RU"
+	}
+	
+	// Convert short codes to TMDB format
+	switch lang {
+	case "en":
+		return "en-US"
+	case "ru":
+		return "ru-RU"
+	default:
+		// Return as-is if already in correct format
+		return lang
+	}
+}

pkg/handlers/movie.go

@@ -29,7 +29,7 @@ func (h *MovieHandler) Search(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	region := r.URL.Query().Get("region")
 	year := getIntQuery(r, "year", 0)
 
@@ -54,7 +54,7 @@ func (h *MovieHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	movie, err := h.movieService.GetByID(id, language)
 	if err != nil {
@@ -71,7 +71,7 @@ func (h *MovieHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 
 func (h *MovieHandler) Popular(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	region := r.URL.Query().Get("region")
 
 	movies, err := h.movieService.GetPopular(page, language, region)
@@ -89,7 +89,7 @@ func (h *MovieHandler) Popular(w http.ResponseWriter, r *http.Request) {
 
 func (h *MovieHandler) TopRated(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	region := r.URL.Query().Get("region")
 
 	movies, err := h.movieService.GetTopRated(page, language, region)
@@ -107,7 +107,7 @@ func (h *MovieHandler) TopRated(w http.ResponseWriter, r *http.Request) {
 
 func (h *MovieHandler) Upcoming(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	region := r.URL.Query().Get("region")
 
 	movies, err := h.movieService.GetUpcoming(page, language, region)
@@ -125,7 +125,7 @@ func (h *MovieHandler) Upcoming(w http.ResponseWriter, r *http.Request) {
 
 func (h *MovieHandler) NowPlaying(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	region := r.URL.Query().Get("region")
 
 	movies, err := h.movieService.GetNowPlaying(page, language, region)
@@ -150,7 +150,7 @@ func (h *MovieHandler) GetRecommendations(w http.ResponseWriter, r *http.Request
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	movies, err := h.movieService.GetRecommendations(id, page, language)
 	if err != nil {
@@ -174,7 +174,7 @@ func (h *MovieHandler) GetSimilar(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	movies, err := h.movieService.GetSimilar(id, page, language)
 	if err != nil {

pkg/handlers/players.go

@@ -7,11 +7,13 @@ import (
 	"log"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"
 
 	"github.com/gorilla/mux"
 	"neomovies-api/pkg/config"
+	"neomovies-api/pkg/players"
 )
 
 type PlayersHandler struct {
@@ -92,9 +94,30 @@ func (h *PlayersHandler) GetAllohaPlayer(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
+	// Получаем параметры для сериалов
+	season := r.URL.Query().Get("season")
+	episode := r.URL.Query().Get("episode")
+	translation := r.URL.Query().Get("translation")
+	if translation == "" {
+		translation = "66" // дефолтная озвучка
+	}
+
+	// Используем iframe URL из API
 	iframeCode := allohaResponse.Data.Iframe
+	
+	// Если это не HTML код, а просто URL
+	var playerURL string
 	if !strings.Contains(iframeCode, "<") {
-		iframeCode = fmt.Sprintf(`<iframe src="%s" allowfullscreen style="border:none;width:100%%;height:100%%"></iframe>`, iframeCode)
+		playerURL = iframeCode
+		// Добавляем параметры для сериалов
+		if season != "" && episode != "" {
+			separator := "?"
+			if strings.Contains(playerURL, "?") {
+				separator = "&"
+			}
+			playerURL = fmt.Sprintf("%s%sseason=%s&episode=%s&translation=%s", playerURL, separator, season, episode, translation)
+		}
+		iframeCode = fmt.Sprintf(`<iframe src="%s" allowfullscreen style="border:none;width:100%%;height:100%%"></iframe>`, playerURL)
 	}
 
 	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>Alloha Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframeCode)
@@ -130,10 +153,11 @@ func (h *PlayersHandler) GetLumexPlayer(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	url := fmt.Sprintf("%s?imdb_id=%s", h.config.LumexURL, url.QueryEscape(imdbID))
+	// Lumex использует только IMDb ID без season/episode
-	log.Printf("Generated Lumex URL: %s", url)
+	playerURL := fmt.Sprintf("%s?imdb_id=%s", h.config.LumexURL, imdbID)
+	log.Printf("🔗 Lumex URL: %s", playerURL)
 
-	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, url)
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, playerURL)
 	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>Lumex Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframe)
 
 	w.Header().Set("Content-Type", "text/html")
@@ -225,9 +249,11 @@ func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	log.Printf("Generated Vibix iframe URL: %s", vibixResponse.IframeURL)
+	// Vibix использует только iframe_url без season/episode
+	playerURL := vibixResponse.IframeURL
+	log.Printf("🔗 Vibix iframe URL: %s", playerURL)
 
-	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, vibixResponse.IframeURL)
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, playerURL)
 	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>Vibix Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframe)
 
 	w.Header().Set("Content-Type", "text/html")
@@ -235,3 +261,345 @@ func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request)
 
 	log.Printf("Successfully served Vibix player for imdb_id: %s", imdbID)
 }
+
+// GetRgShowsPlayer handles RgShows streaming requests
+func (h *PlayersHandler) GetRgShowsPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetRgShowsPlayer called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	tmdbID := vars["tmdb_id"]
+	if tmdbID == "" {
+		log.Printf("Error: tmdb_id is empty")
+		http.Error(w, "tmdb_id path param is required", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing tmdb_id: %s", tmdbID)
+
+	pm := players.NewPlayersManager()
+	result, err := pm.GetMovieStreamByProvider("rgshows", tmdbID)
+	if err != nil {
+		log.Printf("Error getting RgShows stream: %v", err)
+		http.Error(w, "Failed to get stream", http.StatusInternalServerError)
+		return
+	}
+
+	if !result.Success {
+		log.Printf("RgShows stream not found: %s", result.Error)
+		http.Error(w, "Stream not found", http.StatusNotFound)
+		return
+	}
+
+	// Create iframe with the stream URL
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, result.StreamURL)
+	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>RgShows Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframe)
+
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+
+	log.Printf("Successfully served RgShows player for tmdb_id: %s", tmdbID)
+}
+
+// GetRgShowsTVPlayer handles RgShows TV show streaming requests
+func (h *PlayersHandler) GetRgShowsTVPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetRgShowsTVPlayer called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	tmdbID := vars["tmdb_id"]
+	seasonStr := vars["season"]
+	episodeStr := vars["episode"]
+
+	if tmdbID == "" || seasonStr == "" || episodeStr == "" {
+		log.Printf("Error: missing required parameters")
+		http.Error(w, "tmdb_id, season, and episode path params are required", http.StatusBadRequest)
+		return
+	}
+
+	season, err := strconv.Atoi(seasonStr)
+	if err != nil {
+		log.Printf("Error parsing season: %v", err)
+		http.Error(w, "Invalid season number", http.StatusBadRequest)
+		return
+	}
+
+	episode, err := strconv.Atoi(episodeStr)
+	if err != nil {
+		log.Printf("Error parsing episode: %v", err)
+		http.Error(w, "Invalid episode number", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing tmdb_id: %s, season: %d, episode: %d", tmdbID, season, episode)
+
+	pm := players.NewPlayersManager()
+	result, err := pm.GetTVStreamByProvider("rgshows", tmdbID, season, episode)
+	if err != nil {
+		log.Printf("Error getting RgShows TV stream: %v", err)
+		http.Error(w, "Failed to get stream", http.StatusInternalServerError)
+		return
+	}
+
+	if !result.Success {
+		log.Printf("RgShows TV stream not found: %s", result.Error)
+		http.Error(w, "Stream not found", http.StatusNotFound)
+		return
+	}
+
+	// Create iframe with the stream URL
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, result.StreamURL)
+	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>RgShows TV Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframe)
+
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+
+	log.Printf("Successfully served RgShows TV player for tmdb_id: %s, S%dE%d", tmdbID, season, episode)
+}
+
+// GetIframeVideoPlayer handles IframeVideo streaming requests
+func (h *PlayersHandler) GetIframeVideoPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetIframeVideoPlayer called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	kinopoiskID := vars["kinopoisk_id"]
+	imdbID := vars["imdb_id"]
+
+	if kinopoiskID == "" && imdbID == "" {
+		log.Printf("Error: both kinopoisk_id and imdb_id are empty")
+		http.Error(w, "Either kinopoisk_id or imdb_id path param is required", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing kinopoisk_id: %s, imdb_id: %s", kinopoiskID, imdbID)
+
+	pm := players.NewPlayersManager()
+	result, err := pm.GetStreamWithKinopoisk(kinopoiskID, imdbID)
+	if err != nil {
+		log.Printf("Error getting IframeVideo stream: %v", err)
+		http.Error(w, "Failed to get stream", http.StatusInternalServerError)
+		return
+	}
+
+	if !result.Success {
+		log.Printf("IframeVideo stream not found: %s", result.Error)
+		http.Error(w, "Stream not found", http.StatusNotFound)
+		return
+	}
+
+	// Create iframe with the stream URL
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, result.StreamURL)
+	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>IframeVideo Player</title><style>html,body{margin:0;height:100%%;}</style></head><body>%s</body></html>`, iframe)
+
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+
+	log.Printf("Successfully served IframeVideo player for kinopoisk_id: %s, imdb_id: %s", kinopoiskID, imdbID)
+}
+
+// GetStreamAPI returns stream information as JSON API
+func (h *PlayersHandler) GetStreamAPI(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetStreamAPI called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	provider := vars["provider"]
+	tmdbID := vars["tmdb_id"]
+
+	if provider == "" || tmdbID == "" {
+		log.Printf("Error: missing required parameters")
+		http.Error(w, "provider and tmdb_id path params are required", http.StatusBadRequest)
+		return
+	}
+
+	// Check for TV show parameters
+	seasonStr := r.URL.Query().Get("season")
+	episodeStr := r.URL.Query().Get("episode")
+	kinopoiskID := r.URL.Query().Get("kinopoisk_id")
+	imdbID := r.URL.Query().Get("imdb_id")
+
+	log.Printf("Processing provider: %s, tmdb_id: %s", provider, tmdbID)
+
+	pm := players.NewPlayersManager()
+	var result *players.StreamResult
+	var err error
+
+	switch provider {
+	case "iframevideo":
+		if kinopoiskID == "" && imdbID == "" {
+			http.Error(w, "kinopoisk_id or imdb_id query param is required for IframeVideo", http.StatusBadRequest)
+			return
+		}
+		result, err = pm.GetStreamWithKinopoisk(kinopoiskID, imdbID)
+	case "rgshows":
+		if seasonStr != "" && episodeStr != "" {
+			season, err1 := strconv.Atoi(seasonStr)
+			episode, err2 := strconv.Atoi(episodeStr)
+			if err1 != nil || err2 != nil {
+				http.Error(w, "Invalid season or episode number", http.StatusBadRequest)
+				return
+			}
+			result, err = pm.GetTVStreamByProvider("rgshows", tmdbID, season, episode)
+		} else {
+			result, err = pm.GetMovieStreamByProvider("rgshows", tmdbID)
+		}
+	default:
+		http.Error(w, "Unsupported provider", http.StatusBadRequest)
+		return
+	}
+
+	if err != nil {
+		log.Printf("Error getting stream from %s: %v", provider, err)
+		result = &players.StreamResult{
+			Success:  false,
+			Provider: provider,
+			Error:    err.Error(),
+		}
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(result)
+
+	log.Printf("Successfully served stream API for provider: %s, tmdb_id: %s", provider, tmdbID)
+}
+
+// GetVidsrcPlayer handles Vidsrc.to player (uses IMDb ID for both movies and TV shows)
+func (h *PlayersHandler) GetVidsrcPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetVidsrcPlayer called: %s %s", r.Method, r.URL.Path)
+	
+	vars := mux.Vars(r)
+	imdbId := vars["imdb_id"]
+	mediaType := vars["media_type"] // "movie" or "tv"
+	
+	if imdbId == "" || mediaType == "" {
+		http.Error(w, "imdb_id and media_type are required", http.StatusBadRequest)
+		return
+	}
+	
+	var playerURL string
+	if mediaType == "movie" {
+		playerURL = fmt.Sprintf("https://vidsrc.to/embed/movie/%s", imdbId)
+	} else if mediaType == "tv" {
+		season := r.URL.Query().Get("season")
+		episode := r.URL.Query().Get("episode")
+		if season == "" || episode == "" {
+			http.Error(w, "season and episode are required for TV shows", http.StatusBadRequest)
+			return
+		}
+		playerURL = fmt.Sprintf("https://vidsrc.to/embed/tv/%s/%s/%s", imdbId, season, episode)
+	} else {
+		http.Error(w, "Invalid media_type. Use 'movie' or 'tv'", http.StatusBadRequest)
+		return
+	}
+	
+	log.Printf("Generated Vidsrc URL: %s", playerURL)
+	
+	// Используем общий шаблон с кастомными контролами
+	htmlDoc := getPlayerWithControlsHTML(playerURL, "Vidsrc Player")
+	
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+	
+	log.Printf("Successfully served Vidsrc player for %s: %s", mediaType, imdbId)
+}
+
+// GetVidlinkMoviePlayer handles vidlink.pro player for movies (uses IMDb ID)
+func (h *PlayersHandler) GetVidlinkMoviePlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetVidlinkMoviePlayer called: %s %s", r.Method, r.URL.Path)
+	
+	vars := mux.Vars(r)
+	imdbId := vars["imdb_id"]
+	
+	if imdbId == "" {
+		http.Error(w, "imdb_id is required", http.StatusBadRequest)
+		return
+	}
+	
+	playerURL := fmt.Sprintf("https://vidlink.pro/movie/%s", imdbId)
+	
+	log.Printf("Generated Vidlink Movie URL: %s", playerURL)
+	
+	// Используем общий шаблон с кастомными контролами
+	htmlDoc := getPlayerWithControlsHTML(playerURL, "Vidlink Player")
+	
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+	
+	log.Printf("Successfully served Vidlink movie player: %s", imdbId)
+}
+
+// GetVidlinkTVPlayer handles vidlink.pro player for TV shows (uses TMDB ID)
+func (h *PlayersHandler) GetVidlinkTVPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetVidlinkTVPlayer called: %s %s", r.Method, r.URL.Path)
+	
+	vars := mux.Vars(r)
+	tmdbId := vars["tmdb_id"]
+	
+	if tmdbId == "" {
+		http.Error(w, "tmdb_id is required", http.StatusBadRequest)
+		return
+	}
+	
+	season := r.URL.Query().Get("season")
+	episode := r.URL.Query().Get("episode")
+	if season == "" || episode == "" {
+		http.Error(w, "season and episode are required for TV shows", http.StatusBadRequest)
+		return
+	}
+	
+	playerURL := fmt.Sprintf("https://vidlink.pro/tv/%s/%s/%s", tmdbId, season, episode)
+	
+	log.Printf("Generated Vidlink TV URL: %s", playerURL)
+	
+	// Используем общий шаблон с кастомными контролами
+	htmlDoc := getPlayerWithControlsHTML(playerURL, "Vidlink Player")
+	
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+	
+	log.Printf("Successfully served Vidlink TV player: %s S%sE%s", tmdbId, season, episode)
+}
+
+// getPlayerWithControlsHTML возвращает HTML с плеером и overlay для блокировки кликов
+func getPlayerWithControlsHTML(playerURL, title string) string {
+	return fmt.Sprintf(`<!DOCTYPE html>
+<html>
+<head>
+<meta charset='utf-8'/>
+<title>%s</title>
+<style>
+html,body{margin:0;height:100%%;overflow:hidden;background:#000;font-family:Arial,sans-serif;}
+#container{position:relative;width:100%%;height:100%%;}
+#player-iframe{position:absolute;top:0;left:0;width:100%%;height:100%%;border:none;}
+#overlay{position:absolute;top:0;left:0;width:100%%;height:100%%;z-index:10;pointer-events:none;}
+#controls{position:absolute;bottom:0;left:0;right:0;background:linear-gradient(transparent,rgba(0,0,0,0.8));padding:20px;opacity:0;transition:opacity 0.3s;pointer-events:auto;z-index:20;}
+#container:hover #controls{opacity:1;}
+.btn{background:rgba(255,255,255,0.2);border:none;color:#fff;padding:12px 20px;margin:0 5px;border-radius:5px;cursor:pointer;font-size:16px;transition:background 0.2s;}
+.btn:hover{background:rgba(255,255,255,0.4);}
+.btn:active{background:rgba(255,255,255,0.6);}
+</style>
+</head>
+<body>
+<div id="container">
+  <iframe id="player-iframe" src="%s" allowfullscreen allow="autoplay; encrypted-media; fullscreen; picture-in-picture"></iframe>
+  <div id="overlay"></div>
+  <div id="controls">
+    <button class="btn" id="btn-fullscreen" title="Fullscreen">⛶ Fullscreen</button>
+  </div>
+</div>
+<script>
+const overlay=document.getElementById('overlay');
+
+// Блокируем клики на iframe (защита от рекламы)
+overlay.addEventListener('click',(e)=>{e.preventDefault();e.stopPropagation();});
+overlay.addEventListener('mousedown',(e)=>{e.preventDefault();e.stopPropagation();});
+
+// Fullscreen
+document.getElementById('btn-fullscreen').addEventListener('click',()=>{
+  if(!document.fullscreenElement){
+    document.getElementById('container').requestFullscreen();
+  }else{
+    document.exitFullscreen();
+  }
+});
+</script>
+</body>
+</html>`, title, playerURL)
+}

pkg/handlers/search.go

@@ -26,10 +26,7 @@ func (h *SearchHandler) MultiSearch(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
-	if language == "" {
-		language = "ru-RU"
-	}
 
 	results, err := h.tmdbService.SearchMulti(query, page, language)
 	if err != nil {

pkg/handlers/tv.go

@@ -29,7 +29,7 @@ func (h *TVHandler) Search(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 	year := getIntQuery(r, "first_air_date_year", 0)
 
 	tvShows, err := h.tvService.Search(query, page, language, year)
@@ -53,7 +53,7 @@ func (h *TVHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShow, err := h.tvService.GetByID(id, language)
 	if err != nil {
@@ -70,7 +70,7 @@ func (h *TVHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 
 func (h *TVHandler) Popular(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetPopular(page, language)
 	if err != nil {
@@ -87,7 +87,7 @@ func (h *TVHandler) Popular(w http.ResponseWriter, r *http.Request) {
 
 func (h *TVHandler) TopRated(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetTopRated(page, language)
 	if err != nil {
@@ -104,7 +104,7 @@ func (h *TVHandler) TopRated(w http.ResponseWriter, r *http.Request) {
 
 func (h *TVHandler) OnTheAir(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetOnTheAir(page, language)
 	if err != nil {
@@ -121,7 +121,7 @@ func (h *TVHandler) OnTheAir(w http.ResponseWriter, r *http.Request) {
 
 func (h *TVHandler) AiringToday(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetAiringToday(page, language)
 	if err != nil {
@@ -145,7 +145,7 @@ func (h *TVHandler) GetRecommendations(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetRecommendations(id, page, language)
 	if err != nil {
@@ -169,7 +169,7 @@ func (h *TVHandler) GetSimilar(w http.ResponseWriter, r *http.Request) {
 	}
 
 	page := getIntQuery(r, "page", 1)
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
 
 	tvShows, err := h.tvService.GetSimilar(id, page, language)
 	if err != nil {

pkg/players/iframevideo.go

@@ -0,0 +1,208 @@
+package players
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"regexp"
+	"strconv"
+	"time"
+)
+
+// IframeVideoSearchResponse represents the search response from IframeVideo API
+type IframeVideoSearchResponse struct {
+	Results []struct {
+		CID  int    `json:"cid"`
+		Path string `json:"path"`
+		Type string `json:"type"`
+	} `json:"results"`
+}
+
+// IframeVideoResponse represents the video response from IframeVideo API
+type IframeVideoResponse struct {
+	Source string `json:"src"`
+}
+
+// IframeVideoPlayer implements the IframeVideo streaming service
+type IframeVideoPlayer struct {
+	APIHost string
+	CDNHost string
+	Client  *http.Client
+}
+
+// NewIframeVideoPlayer creates a new IframeVideo player instance
+func NewIframeVideoPlayer() *IframeVideoPlayer {
+	return &IframeVideoPlayer{
+		APIHost: "https://iframe.video",
+		CDNHost: "https://videoframe.space",
+		Client: &http.Client{
+			Timeout: 8 * time.Second,
+		},
+	}
+}
+
+// GetStream gets streaming URL by Kinopoisk ID and IMDB ID
+func (i *IframeVideoPlayer) GetStream(kinopoiskID, imdbID string) (*StreamResult, error) {
+	// First, search for content
+	searchResult, err := i.searchContent(kinopoiskID, imdbID)
+	if err != nil {
+		return nil, fmt.Errorf("search failed: %w", err)
+	}
+
+	// Get iframe content to extract token
+	token, err := i.extractToken(searchResult.Path)
+	if err != nil {
+		return nil, fmt.Errorf("token extraction failed: %w", err)
+	}
+
+	// Get video URL
+	return i.getVideoURL(searchResult.CID, token, searchResult.Type)
+}
+
+// searchContent searches for content by Kinopoisk and IMDB IDs
+func (i *IframeVideoPlayer) searchContent(kinopoiskID, imdbID string) (*struct {
+	CID  int
+	Path string
+	Type string
+}, error) {
+	url := fmt.Sprintf("%s/api/v2/search?imdb=%s&kp=%s", i.APIHost, imdbID, kinopoiskID)
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
+
+	resp, err := i.Client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch search results: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API returned status: %d", resp.StatusCode)
+	}
+
+	var searchResp IframeVideoSearchResponse
+	if err := json.NewDecoder(resp.Body).Decode(&searchResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	if len(searchResp.Results) == 0 {
+		return nil, fmt.Errorf("content not found")
+	}
+
+	result := searchResp.Results[0]
+	return &struct {
+		CID  int
+		Path string
+		Type string
+	}{
+		CID:  result.CID,
+		Path: result.Path,
+		Type: result.Type,
+	}, nil
+}
+
+// extractToken extracts token from iframe HTML content
+func (i *IframeVideoPlayer) extractToken(path string) (string, error) {
+	req, err := http.NewRequest("GET", path, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Set headers similar to C# implementation
+	req.Header.Set("DNT", "1")
+	req.Header.Set("Referer", i.CDNHost+"/")
+	req.Header.Set("Sec-Fetch-Dest", "iframe")
+	req.Header.Set("Sec-Fetch-Mode", "navigate")
+	req.Header.Set("Sec-Fetch-Site", "cross-site")
+	req.Header.Set("Upgrade-Insecure-Requests", "1")
+	req.Header.Set("sec-ch-ua", `"Google Chrome";v="113", "Chromium";v="113", "Not-A.Brand";v="24"`)
+	req.Header.Set("sec-ch-ua-mobile", "?0")
+	req.Header.Set("sec-ch-ua-platform", `"Windows"`)
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
+
+	resp, err := i.Client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("failed to fetch iframe content: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("iframe returned status: %d", resp.StatusCode)
+	}
+
+	content, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read iframe content: %w", err)
+	}
+
+	// Extract token using regex as in C# implementation
+	re := regexp.MustCompile(`\/[^\/]+\/([^\/]+)\/iframe`)
+	matches := re.FindStringSubmatch(string(content))
+	if len(matches) < 2 {
+		return "", fmt.Errorf("token not found in iframe content")
+	}
+
+	return matches[1], nil
+}
+
+// getVideoURL gets video URL using extracted token
+func (i *IframeVideoPlayer) getVideoURL(cid int, token, mediaType string) (*StreamResult, error) {
+	// Create multipart form data
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+
+	writer.WriteField("token", token)
+	writer.WriteField("type", mediaType)
+	writer.WriteField("season", "")
+	writer.WriteField("episode", "")
+	writer.WriteField("mobile", "false")
+	writer.WriteField("id", strconv.Itoa(cid))
+	writer.WriteField("qt", "480")
+
+	contentType := writer.FormDataContentType()
+	writer.Close()
+
+	req, err := http.NewRequest("POST", i.CDNHost+"/loadvideo", &buf)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", contentType)
+	req.Header.Set("Origin", i.CDNHost)
+	req.Header.Set("Referer", i.CDNHost+"/")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
+
+	resp, err := i.Client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch video URL: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("video API returned status: %d", resp.StatusCode)
+	}
+
+	var videoResp IframeVideoResponse
+	if err := json.NewDecoder(resp.Body).Decode(&videoResp); err != nil {
+		return nil, fmt.Errorf("failed to decode video response: %w", err)
+	}
+
+	if videoResp.Source == "" {
+		return nil, fmt.Errorf("video URL not found")
+	}
+
+	return &StreamResult{
+		Success:   true,
+		StreamURL: videoResp.Source,
+		Provider:  "IframeVideo",
+		Type:      "direct",
+	}, nil
+}

pkg/players/rgshows.go

@@ -0,0 +1,81 @@
+package players
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+)
+
+// RgShowsResponse represents the response from RgShows API
+type RgShowsResponse struct {
+	Stream *struct {
+		URL string `json:"url"`
+	} `json:"stream"`
+}
+
+// RgShowsPlayer implements the RgShows streaming service
+type RgShowsPlayer struct {
+	BaseURL string
+	Client  *http.Client
+}
+
+// NewRgShowsPlayer creates a new RgShows player instance
+func NewRgShowsPlayer() *RgShowsPlayer {
+	return &RgShowsPlayer{
+		BaseURL: "https://rgshows.com",
+		Client: &http.Client{
+			Timeout: 40 * time.Second,
+		},
+	}
+}
+
+// GetMovieStream gets streaming URL for a movie by TMDB ID
+func (r *RgShowsPlayer) GetMovieStream(tmdbID string) (*StreamResult, error) {
+	url := fmt.Sprintf("%s/main/movie/%s", r.BaseURL, tmdbID)
+	return r.fetchStream(url)
+}
+
+// GetTVStream gets streaming URL for a TV show episode by TMDB ID, season and episode
+func (r *RgShowsPlayer) GetTVStream(tmdbID string, season, episode int) (*StreamResult, error) {
+	url := fmt.Sprintf("%s/main/tv/%s/%d/%d", r.BaseURL, tmdbID, season, episode)
+	return r.fetchStream(url)
+}
+
+// fetchStream makes HTTP request to RgShows API and extracts stream URL
+func (r *RgShowsPlayer) fetchStream(url string) (*StreamResult, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	// Set headers similar to the C# implementation
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36")
+
+	resp, err := r.Client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to fetch stream: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API returned status: %d", resp.StatusCode)
+	}
+
+	var rgResp RgShowsResponse
+	if err := json.NewDecoder(resp.Body).Decode(&rgResp); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	if rgResp.Stream == nil || rgResp.Stream.URL == "" {
+		return nil, fmt.Errorf("stream not found")
+	}
+
+	return &StreamResult{
+		Success:   true,
+		StreamURL: rgResp.Stream.URL,
+		Provider:  "RgShows",
+		Type:      "direct",
+	}, nil
+}

pkg/players/types.go

@@ -0,0 +1,99 @@
+package players
+
+// StreamResult represents the result of a streaming request
+type StreamResult struct {
+	Success   bool   `json:"success"`
+	StreamURL string `json:"stream_url,omitempty"`
+	Provider  string `json:"provider"`
+	Type      string `json:"type"` // "direct", "iframe", "hls", etc.
+	Error     string `json:"error,omitempty"`
+}
+
+// Player interface defines methods for streaming providers
+type Player interface {
+	GetMovieStream(tmdbID string) (*StreamResult, error)
+	GetTVStream(tmdbID string, season, episode int) (*StreamResult, error)
+}
+
+// PlayersManager manages all available streaming players
+type PlayersManager struct {
+	rgshows     *RgShowsPlayer
+	iframevideo *IframeVideoPlayer
+}
+
+// NewPlayersManager creates a new players manager
+func NewPlayersManager() *PlayersManager {
+	return &PlayersManager{
+		rgshows:     NewRgShowsPlayer(),
+		iframevideo: NewIframeVideoPlayer(),
+	}
+}
+
+// GetMovieStreams tries to get movie streams from all available providers
+func (pm *PlayersManager) GetMovieStreams(tmdbID string) []*StreamResult {
+	var results []*StreamResult
+
+	// Try RgShows
+	if stream, err := pm.rgshows.GetMovieStream(tmdbID); err == nil {
+		results = append(results, stream)
+	} else {
+		results = append(results, &StreamResult{
+			Success:  false,
+			Provider: "RgShows",
+			Error:    err.Error(),
+		})
+	}
+
+	return results
+}
+
+// GetTVStreams tries to get TV show streams from all available providers
+func (pm *PlayersManager) GetTVStreams(tmdbID string, season, episode int) []*StreamResult {
+	var results []*StreamResult
+
+	// Try RgShows
+	if stream, err := pm.rgshows.GetTVStream(tmdbID, season, episode); err == nil {
+		results = append(results, stream)
+	} else {
+		results = append(results, &StreamResult{
+			Success:  false,
+			Provider: "RgShows",
+			Error:    err.Error(),
+		})
+	}
+
+	return results
+}
+
+// GetMovieStreamByProvider gets movie stream from specific provider
+func (pm *PlayersManager) GetMovieStreamByProvider(provider, tmdbID string) (*StreamResult, error) {
+	switch provider {
+	case "rgshows":
+		return pm.rgshows.GetMovieStream(tmdbID)
+	default:
+		return &StreamResult{
+			Success:  false,
+			Provider: provider,
+			Error:    "provider not found",
+		}, nil
+	}
+}
+
+// GetTVStreamByProvider gets TV stream from specific provider
+func (pm *PlayersManager) GetTVStreamByProvider(provider, tmdbID string, season, episode int) (*StreamResult, error) {
+	switch provider {
+	case "rgshows":
+		return pm.rgshows.GetTVStream(tmdbID, season, episode)
+	default:
+		return &StreamResult{
+			Success:  false,
+			Provider: provider,
+			Error:    "provider not found",
+		}, nil
+	}
+}
+
+// GetStreamWithKinopoisk gets stream using Kinopoisk ID and IMDB ID (for IframeVideo)
+func (pm *PlayersManager) GetStreamWithKinopoisk(kinopoiskID, imdbID string) (*StreamResult, error) {
+	return pm.iframevideo.GetStream(kinopoiskID, imdbID)
+}