feat(search): include originalType (FILM/TV_SERIES) for KP results; ensure KP poster/backdrop proxied

- Add TMDBID field to ExternalIDs model
- Enhance GetExternalIDs in MovieService and TVService to fetch TMDB ID via FindTMDBIdByIMDB
- Add EnrichKPWithTMDBID function to enrich unified content with TMDB IDs
- Update unified handlers to automatically enrich KP content with TMDB IDs
- Enrich search results with TMDB IDs by fetching full film data for each result

This ensures that when using source=kp, the response includes TMDB IDs in externalIds
when available through IMDB ID mapping, while preserving all original KP data.

.env.example

@@ -1,28 +1,34 @@
-# Required
+MONGO_URI=mongodb://localhost:27017/neomovies
-MONGO_URI=
+MONGO_DB_NAME=neomovies
-MONGO_DB_NAME=database
-TMDB_ACCESS_TOKEN=
-JWT_SECRET=
 
-# Service
+TMDB_ACCESS_TOKEN=your_tmdb_access_token
-PORT=3000
-BASE_URL=http://localhost:3000
-NODE_ENV=development
 
-# Email (Gmail)
+KPAPI_KEY=your_kp_api_key
-GMAIL_USER=
+KPAPI_BASE_URL=https://kinopoiskapiunofficial.tech/api
-GMAIL_APP_PASSWORD=
 
-# Players
+HDVB_TOKEN=your_hdvb_token
-LUMEX_URL=
+
-ALLOHA_TOKEN=
+VIBIX_HOST=https://vibix.org
+VIBIX_TOKEN=your_vibix_token
+
+LUMEX_URL=https://p.lumex.space
+
+ALLOHA_TOKEN=your_alloha_token
 
-# Torrents (RedAPI)
 REDAPI_BASE_URL=http://redapi.cfhttp.top
-REDAPI_KEY=
+REDAPI_KEY=your_redapi_key
 
-# Google OAuth
+JWT_SECRET=your_jwt_secret_key
-GOOGLE_CLIENT_ID=
+
-GOOGLE_CLIENT_SECRET=
+GMAIL_USER=your_gmail@gmail.com
+GMAIL_APP_PASSWORD=your_gmail_app_password
+
+GOOGLE_CLIENT_ID=your_google_client_id
+GOOGLE_CLIENT_SECRET=your_google_client_secret
 GOOGLE_REDIRECT_URL=http://localhost:3000/api/v1/auth/google/callback
-FRONTEND_URL=http://localhost:3001
+
+BASE_URL=http://localhost:3000
+FRONTEND_URL=http://localhost:3001
+
+PORT=3000
+NODE_ENV=development

.gitignore

@@ -2,4 +2,12 @@
 .env.local
 node_modules
 package-lock.json
-yarn.lock
+yarn.lock
+# Binaries
+bin/
+main
+*.exe
+*.dll
+*.so
+*.dylib
+neomovies-api

README.md

@@ -1,16 +1,17 @@
-# Neo Movies API
+# Neo Movies API (Unified)
 
 REST API для поиска и получения информации о фильмах, использующий TMDB API.
 
 ## Особенности
 
-- Поиск фильмов
+- Интеграция с Kinopoisk API для русского контента
+- Автоматическое переключение между TMDB и Kinopoisk
+- Поиск фильмов и сериалов
 - Информация о фильмах
-- Популярные фильмы
+- Популярные, топ-рейтинговые, предстоящие фильмы
-- Топ рейтинговые фильмы
+- Поддержка русских плееров (Alloha, Lumex, Vibix, HDVB)
-- Предстоящие фильмы
 - Swagger документация
-- Поддержка русского языка
+- Полная поддержка русского языка
 
 ## 🛠 Быстрый старт
 
@@ -50,38 +51,45 @@ API будет доступен на `http://localhost:3000`
 
 ```bash
 # Обязательные
-MONGO_URI=
+MONGO_URI=mongodb://localhost:27017/neomovies
-MONGO_DB_NAME=database
+MONGO_DB_NAME=neomovies
-TMDB_ACCESS_TOKEN=
+TMDB_ACCESS_TOKEN=your_tmdb_access_token
-JWT_SECRET=
+JWT_SECRET=your_jwt_secret_key
+
+# Kinopoisk API
+KPAPI_KEY=your_kp_api_key
+KPAPI_BASE_URL=https://kinopoiskapiunofficial.tech/api
 
 # Сервис
 PORT=3000
 BASE_URL=http://localhost:3000
+FRONTEND_URL=http://localhost:3001
 NODE_ENV=development
 
 # Email (Gmail)
-GMAIL_USER=
+GMAIL_USER=your_gmail@gmail.com
-GMAIL_APP_PASSWORD=
+GMAIL_APP_PASSWORD=your_gmail_app_password
 
-# Плееры
+# Русские плееры
-LUMEX_URL=
+LUMEX_URL=https://p.lumex.space
-ALLOHA_TOKEN=
+ALLOHA_TOKEN=your_alloha_token
-VIBIX_TOKEN=
+VIBIX_HOST=https://vibix.org
+VIBIX_TOKEN=your_vibix_token
+HDVB_TOKEN=your_hdvb_token
 
 # Торренты (RedAPI)
 REDAPI_BASE_URL=http://redapi.cfhttp.top
-REDAPI_KEY=
+REDAPI_KEY=your_redapi_key
 
 # Google OAuth
-GOOGLE_CLIENT_ID=
+GOOGLE_CLIENT_ID=your_google_client_id
-GOOGLE_CLIENT_SECRET=
+GOOGLE_CLIENT_SECRET=your_google_client_secret
 GOOGLE_REDIRECT_URL=http://localhost:3000/api/v1/auth/google/callback
 ```
 
 ## 📋 API Endpoints
 
-### 🔓 Публичные маршруты
+### 🔓 Публичные маршруты (старые)
 
 ```http
 # Система
@@ -106,7 +114,7 @@ GET  /api/v1/movies/popular                  # Популярные
 GET  /api/v1/movies/top-rated                # Топ-рейтинговые
 GET  /api/v1/movies/upcoming                 # Предстоящие
 GET  /api/v1/movies/now-playing              # В прокате
-GET  /api/v1/movies/{id}                     # Детали фильма
+GET  /api/v1/movies/{id}                     # Детали фильма (устар.)
 GET  /api/v1/movies/{id}/recommendations     # Рекомендации
 GET  /api/v1/movies/{id}/similar             # Похожие
 
@@ -116,14 +124,97 @@ GET  /api/v1/tv/popular                      # Популярные
 GET  /api/v1/tv/top-rated                    # Топ-рейтинговые
 GET  /api/v1/tv/on-the-air                   # В эфире
 GET  /api/v1/tv/airing-today                 # Сегодня в эфире
-GET  /api/v1/tv/{id}                         # Детали сериала
+GET  /api/v1/tv/{id}                         # Детали сериала (устар.)
+### 🔓 Публичные маршруты (унифицированные)
+
+```http
+# Единый формат ID: SOURCE_ID = kp_123 | tmdb_456
+GET  /api/v1/movie/{SOURCE_ID}               # Детали фильма (унифицированный ответ)
+GET  /api/v1/tv/{SOURCE_ID}                  # Детали сериала (унифицированный ответ, с seasons[])
+GET  /api/v1/search?query=...&source=kp|tmdb # Мультипоиск (унифицированные элементы)
+```
+
+Примеры:
+
+```http
+GET /api/v1/movie/tmdb_550
+GET /api/v1/movie/kp_666
+GET /api/v1/tv/tmdb_1399
+GET /api/v1/search?query=matrix&source=tmdb
+```
+
+Схема ответа см. раздел «Unified responses» ниже.
+
+## Unified responses
+
+Пример карточки:
+
+```json
+{
+  "success": true,
+  "data": {
+    "id": "550",
+    "sourceId": "tmdb_550",
+    "title": "Fight Club",
+    "originalTitle": "Fight Club",
+    "description": "…",
+    "releaseDate": "1999-10-15",
+    "endDate": null,
+    "type": "movie",
+    "genres": [{ "id": "drama", "name": "Drama" }],
+    "rating": 8.8,
+    "posterUrl": "https://image.tmdb.org/t/p/w500/...jpg",
+    "backdropUrl": "https://image.tmdb.org/t/p/w1280/...jpg",
+    "director": "",
+    "cast": [],
+    "duration": 139,
+    "country": "US",
+    "language": "en",
+    "budget": 63000000,
+    "revenue": 100853753,
+    "imdbId": "0137523",
+    "externalIds": { "kp": null, "tmdb": 550, "imdb": "0137523" },
+    "seasons": []
+  },
+  "source": "tmdb",
+  "metadata": { "fetchedAt": "...", "apiVersion": "3.0", "responseTime": 12 }
+}
+```
+
+Пример мультипоиска:
+
+```json
+{
+  "success": true,
+  "data": [
+    {
+      "id": "550",
+      "sourceId": "tmdb_550",
+      "title": "Fight Club",
+      "type": "movie",
+      "releaseDate": "1999-10-15",
+      "posterUrl": "https://image.tmdb.org/t/p/w500/...jpg",
+      "rating": 8.8,
+      "description": "…",
+      "externalIds": { "kp": null, "tmdb": 550, "imdb": "" }
+    }
+  ],
+  "source": "tmdb",
+  "pagination": { "page": 1, "totalPages": 5, "totalResults": 42, "pageSize": 20 },
+  "metadata": { "fetchedAt": "...", "apiVersion": "3.0", "responseTime": 20, "query": "fight" }
+}
+```
 GET  /api/v1/tv/{id}/recommendations         # Рекомендации
 GET  /api/v1/tv/{id}/similar                 # Похожие
 
-# Плееры
+# Плееры (новый формат с типом ID)
-GET  /api/v1/players/alloha/{imdb_id}          # Alloha плеер по IMDb ID
+GET  /api/v1/players/alloha/{id_type}/{id}    # Alloha плеер (kp/301 или imdb/tt0133093)
-GET  /api/v1/players/lumex/{imdb_id}           # Lumex плеер по IMDb ID
+GET  /api/v1/players/lumex/{id_type}/{id}     # Lumex плеер (kp/301 или imdb/tt0133093)
-GET  /api/v1/players/vibix/{imdb_id}           # Vibix плеер по IMDb ID
+GET  /api/v1/players/vibix/{id_type}/{id}     # Vibix плеер (kp/301 или imdb/tt0133093)
+GET  /api/v1/players/hdvb/{id_type}/{id}      # HDVB плеер (kp/301 или imdb/tt0133093)
+GET  /api/v1/players/vidsrc/{media_type}/{imdb_id}  # Vidsrc (только IMDB)
+GET  /api/v1/players/vidlink/movie/{imdb_id}       # Vidlink фильмы (только IMDB)
+GET  /api/v1/players/vidlink/tv/{tmdb_id}          # Vidlink сериалы (только TMDB)
 
 # Торренты
 GET  /api/v1/torrents/search/{imdbId}        # Поиск торрентов
@@ -243,10 +334,42 @@ curl "https://api.neomovies.ru/api/v1/torrents/search/tt0111161?type=movie&quali
 - **Gorilla Mux** - HTTP роутер
 - **MongoDB** - база данных
 - **JWT** - аутентификация
-- **TMDB API** - данные о фильмах
+- **TMDB API** - данные о фильмах (международный контент)
+- **Kinopoisk API Unofficial** - данные о русском контенте
 - **Gmail SMTP** - email уведомления
 - **Vercel** - деплой и хостинг
 
+## 🌍 Kinopoisk API интеграция
+
+API автоматически переключается между TMDB и Kinopoisk в зависимости от языка запроса:
+
+- **Русский язык (`lang=ru`)** → Kinopoisk API
+  - Русские названия фильмов
+  - Рейтинги Кинопоиска
+  - Поддержка Kinopoisk ID
+  
+- **Английский язык (`lang=en`)** → TMDB API
+  - Международные названия
+  - Рейтинги IMDB/TMDB
+  - Поддержка IMDB/TMDB ID
+
+### Формат ID в плеерах
+
+Все русские плееры поддерживают два типа идентификаторов:
+
+```bash
+# По Kinopoisk ID (приоритет для русского контента)
+GET /api/v1/players/alloha/kp/301
+
+# По IMDB ID (fallback)
+GET /api/v1/players/alloha/imdb/tt0133093
+
+# Примеры для других плееров
+GET /api/v1/players/lumex/kp/301
+GET /api/v1/players/vibix/kp/301
+GET /api/v1/players/hdvb/kp/301
+```
+
 ## 🚀 Производительность
 
 По сравнению с Node.js версией:

api/index.go

@@ -52,11 +52,12 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	tmdbService := services.NewTMDBService(globalCfg.TMDBAccessToken)
+	kpService := services.NewKinopoiskService(globalCfg.KPAPIKey, globalCfg.KPAPIBaseURL)
 	emailService := services.NewEmailService(globalCfg)
 	authService := services.NewAuthService(globalDB, globalCfg.JWTSecret, emailService, globalCfg.BaseURL, globalCfg.GoogleClientID, globalCfg.GoogleClientSecret, globalCfg.GoogleRedirectURL, globalCfg.FrontendURL)
 
-	movieService := services.NewMovieService(globalDB, tmdbService)
+	movieService := services.NewMovieService(globalDB, tmdbService, kpService)
-	tvService := services.NewTVService(globalDB, tmdbService)
+	tvService := services.NewTVService(globalDB, tmdbService, kpService)
 	favoritesService := services.NewFavoritesService(globalDB, tmdbService)
 	torrentService := services.NewTorrentServiceWithConfig(globalCfg.RedAPIBaseURL, globalCfg.RedAPIKey)
 	reactionsService := services.NewReactionsService(globalDB)
@@ -66,7 +67,8 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	tvHandler := handlersPkg.NewTVHandler(tvService)
 	favoritesHandler := handlersPkg.NewFavoritesHandler(favoritesService, globalCfg)
 	docsHandler := handlersPkg.NewDocsHandler()
-	searchHandler := handlersPkg.NewSearchHandler(tmdbService)
+    searchHandler := handlersPkg.NewSearchHandler(tmdbService, kpService)
+    unifiedHandler := handlersPkg.NewUnifiedHandler(tmdbService, kpService)
 	categoriesHandler := handlersPkg.NewCategoriesHandler(tmdbService)
 	playersHandler := handlersPkg.NewPlayersHandler(globalCfg)
 	torrentsHandler := handlersPkg.NewTorrentsHandler(torrentService, tmdbService)
@@ -94,8 +96,13 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	api.HandleFunc("/categories/{id}/movies", categoriesHandler.GetMoviesByCategory).Methods("GET")
 	api.HandleFunc("/categories/{id}/media", categoriesHandler.GetMediaByCategory).Methods("GET")
 
-	api.HandleFunc("/players/alloha/{imdb_id}", playersHandler.GetAllohaPlayer).Methods("GET")
+	api.HandleFunc("/players/alloha/{id_type}/{id}", playersHandler.GetAllohaPlayer).Methods("GET")
-	api.HandleFunc("/players/lumex/{imdb_id}", playersHandler.GetLumexPlayer).Methods("GET")
+	api.HandleFunc("/players/lumex/{id_type}/{id}", playersHandler.GetLumexPlayer).Methods("GET")
+	api.HandleFunc("/players/vibix/{id_type}/{id}", playersHandler.GetVibixPlayer).Methods("GET")
+	api.HandleFunc("/players/hdvb/{id_type}/{id}", playersHandler.GetHDVBPlayer).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")
@@ -117,7 +124,11 @@ func Handler(w http.ResponseWriter, r *http.Request) {
 	api.HandleFunc("/movies/top-rated", movieHandler.TopRated).Methods("GET")
 	api.HandleFunc("/movies/upcoming", movieHandler.Upcoming).Methods("GET")
 	api.HandleFunc("/movies/now-playing", movieHandler.NowPlaying).Methods("GET")
-	api.HandleFunc("/movies/{id}", movieHandler.GetByID).Methods("GET")
+    api.HandleFunc("/movies/{id}", movieHandler.GetByID).Methods("GET")
+    // Unified prefixed routes
+    api.HandleFunc("/movie/{id}", unifiedHandler.GetMovie).Methods("GET")
+    api.HandleFunc("/tv/{id}", unifiedHandler.GetTV).Methods("GET")
+    api.HandleFunc("/search", unifiedHandler.Search).Methods("GET")
 	api.HandleFunc("/movies/{id}/recommendations", movieHandler.GetRecommendations).Methods("GET")
 	api.HandleFunc("/movies/{id}/similar", movieHandler.GetSimilar).Methods("GET")
 	api.HandleFunc("/movies/{id}/external-ids", movieHandler.GetExternalIDs).Methods("GET")
@@ -149,11 +160,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"}),
+		}),
-		handlers.AllowCredentials(),
+		handlers.AllowedMethods([]string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH", "HEAD"}),
+		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

@@ -32,11 +32,12 @@ func main() {
 	defer database.Disconnect()
 
 	tmdbService := services.NewTMDBService(cfg.TMDBAccessToken)
+	kpService := services.NewKinopoiskService(cfg.KPAPIKey, cfg.KPAPIBaseURL)
 	emailService := services.NewEmailService(cfg)
 	authService := services.NewAuthService(db, cfg.JWTSecret, emailService, cfg.BaseURL, cfg.GoogleClientID, cfg.GoogleClientSecret, cfg.GoogleRedirectURL, cfg.FrontendURL)
 
-	movieService := services.NewMovieService(db, tmdbService)
+	movieService := services.NewMovieService(db, tmdbService, kpService)
-	tvService := services.NewTVService(db, tmdbService)
+	tvService := services.NewTVService(db, tmdbService, kpService)
 	favoritesService := services.NewFavoritesService(db, tmdbService)
 	torrentService := services.NewTorrentServiceWithConfig(cfg.RedAPIBaseURL, cfg.RedAPIKey)
 	reactionsService := services.NewReactionsService(db)
@@ -46,7 +47,8 @@ func main() {
 	tvHandler := appHandlers.NewTVHandler(tvService)
 	favoritesHandler := appHandlers.NewFavoritesHandler(favoritesService, cfg)
 	docsHandler := appHandlers.NewDocsHandler()
-	searchHandler := appHandlers.NewSearchHandler(tmdbService)
+    searchHandler := appHandlers.NewSearchHandler(tmdbService, kpService)
+    unifiedHandler := appHandlers.NewUnifiedHandler(tmdbService, kpService)
 	categoriesHandler := appHandlers.NewCategoriesHandler(tmdbService)
 	playersHandler := appHandlers.NewPlayersHandler(cfg)
 	torrentsHandler := appHandlers.NewTorrentsHandler(torrentService, tmdbService)
@@ -75,9 +77,13 @@ func main() {
 	api.HandleFunc("/categories/{id}/movies", categoriesHandler.GetMoviesByCategory).Methods("GET")
 	api.HandleFunc("/categories/{id}/media", categoriesHandler.GetMediaByCategory).Methods("GET")
 
-	api.HandleFunc("/players/alloha/{imdb_id}", playersHandler.GetAllohaPlayer).Methods("GET")
+	api.HandleFunc("/players/alloha/{id_type}/{id}", playersHandler.GetAllohaPlayer).Methods("GET")
-	api.HandleFunc("/players/lumex/{imdb_id}", playersHandler.GetLumexPlayer).Methods("GET")
+	api.HandleFunc("/players/lumex/{id_type}/{id}", playersHandler.GetLumexPlayer).Methods("GET")
-	api.HandleFunc("/players/vibix/{imdb_id}", playersHandler.GetVibixPlayer).Methods("GET")
+	api.HandleFunc("/players/vibix/{id_type}/{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/hdvb/{id_type}/{id}", playersHandler.GetHDVBPlayer).Methods("GET")
 
 	api.HandleFunc("/torrents/search/{imdbId}", torrentsHandler.SearchTorrents).Methods("GET")
 	api.HandleFunc("/torrents/movies", torrentsHandler.SearchMovies).Methods("GET")
@@ -95,7 +101,11 @@ func main() {
 	api.HandleFunc("/movies/top-rated", movieHandler.TopRated).Methods("GET")
 	api.HandleFunc("/movies/upcoming", movieHandler.Upcoming).Methods("GET")
 	api.HandleFunc("/movies/now-playing", movieHandler.NowPlaying).Methods("GET")
-	api.HandleFunc("/movies/{id}", movieHandler.GetByID).Methods("GET")
+    api.HandleFunc("/movies/{id}", movieHandler.GetByID).Methods("GET")
+    // Unified prefixed routes
+    api.HandleFunc("/movie/{id}", unifiedHandler.GetMovie).Methods("GET")
+    api.HandleFunc("/tv/{id}", unifiedHandler.GetTV).Methods("GET")
+    api.HandleFunc("/search", unifiedHandler.Search).Methods("GET")
 	api.HandleFunc("/movies/{id}/recommendations", movieHandler.GetRecommendations).Methods("GET")
 	api.HandleFunc("/movies/{id}/similar", movieHandler.GetSimilar).Methods("GET")
 	api.HandleFunc("/movies/{id}/external-ids", movieHandler.GetExternalIDs).Methods("GET")
@@ -129,12 +139,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/config/config.go

@@ -25,6 +25,9 @@ type Config struct {
 	FrontendURL        string
 	VibixHost          string
 	VibixToken         string
+	KPAPIKey           string
+	HDVBToken          string
+	KPAPIBaseURL       string
 }
 
 func New() *Config {
@@ -50,6 +53,9 @@ func New() *Config {
 		FrontendURL:        getEnv(EnvFrontendURL, ""),
 		VibixHost:          getEnv(EnvVibixHost, DefaultVibixHost),
 		VibixToken:         getEnv(EnvVibixToken, ""),
+		KPAPIKey:           getEnv(EnvKPAPIKey, ""),
+		HDVBToken:          getEnv(EnvHDVBToken, ""),
+		KPAPIBaseURL:       getEnv("KPAPI_BASE_URL", DefaultKPAPIBase),
 	}
 }
 

pkg/config/vars.go

@@ -20,6 +20,8 @@ const (
 	EnvFrontendURL        = "FRONTEND_URL"
 	EnvVibixHost          = "VIBIX_HOST"
 	EnvVibixToken         = "VIBIX_TOKEN"
+	EnvKPAPIKey           = "KPAPI_KEY"
+	EnvHDVBToken          = "HDVB_TOKEN"
 
 	// Default values
 	DefaultJWTSecret   = "your-secret-key"
@@ -29,6 +31,7 @@ const (
 	DefaultRedAPIBase  = "http://redapi.cfhttp.top"
 	DefaultMongoDBName = "database"
 	DefaultVibixHost   = "https://vibix.org"
+	DefaultKPAPIBase   = "https://kinopoiskapiunofficial.tech/api"
 
 	// Static constants
 	TMDBImageBaseURL = "https://image.tmdb.org/t/p"

pkg/handlers/docs.go

@@ -37,11 +37,16 @@ func (h *DocsHandler) GetOpenAPISpec(w http.ResponseWriter, r *http.Request) {
 }
 
 func (h *DocsHandler) ServeDocs(w http.ResponseWriter, r *http.Request) {
-	baseURL := determineBaseURL(r)
+	spec := getOpenAPISpecWithURL("/")
+	specJSON, err := json.Marshal(spec)
+	if err != nil {
+		fmt.Printf("Error marshaling OpenAPI spec: %v", err)
+		http.Error(w, fmt.Sprintf("Error marshaling spec: %v", err), http.StatusInternalServerError)
+		return
+	}
 
-	// Use absolute SpecURL so the library does not try to read a local file path
 	htmlContent, err := scalar.ApiReferenceHTML(&scalar.Options{
-		SpecURL: fmt.Sprintf("%s/openapi.json", baseURL),
+		SpecContent: string(specJSON),
 		CustomOptions: scalar.CustomOptions{
 			PageTitle: "Neo Movies API Documentation",
 		},
@@ -56,6 +61,9 @@ func (h *DocsHandler) ServeDocs(w http.ResponseWriter, r *http.Request) {
 
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	w.Header().Set("Access-Control-Allow-Origin", "*")
+	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
+	w.Header().Set("Pragma", "no-cache")
+	w.Header().Set("Expires", "0")
 	fmt.Fprintln(w, htmlContent)
 }
 
@@ -153,8 +161,8 @@ func getOpenAPISpecWithURL(baseURL string) *OpenAPISpec {
 		OpenAPI: "3.0.0",
 		Info: Info{
 			Title:       "Neo Movies API",
-			Description: "Современный API для поиска фильмов и сериалов с интеграцией TMDB и поддержкой авторизации",
+            Description: "Унифицированный API (TMDB/Kinopoisk) с префиксными ID (kp_*, tmdb_*) и единым форматом данных",
-			Version:     "2.0.0",
+            Version:     "3.0.0",
 			Contact: Contact{
 				Name: "API Support",
 				URL:  "https://github.com/your-username/neomovies-api-go",
@@ -186,10 +194,10 @@ func getOpenAPISpecWithURL(baseURL string) *OpenAPISpec {
 					},
 				},
 			},
-			"/api/v1/search/multi": map[string]interface{}{
+            "/api/v1/search": map[string]interface{}{
 				"get": map[string]interface{}{
-					"summary":     "Мультипоиск",
+                    "summary":     "Унифицированный поиск",
-					"description": "Поиск фильмов, сериалов и актеров",
+                    "description": "Поиск фильмов и сериалов в источниках TMDB или Kinopoisk",
 					"tags":        []string{"Search"},
 					"parameters": []map[string]interface{}{
 						{
@@ -199,6 +207,13 @@ func getOpenAPISpecWithURL(baseURL string) *OpenAPISpec {
 							"schema":      map[string]string{"type": "string"},
 							"description": "Поисковый запрос",
 						},
+                        {
+                            "name":        "source",
+                            "in":          "query",
+                            "required":    true,
+                            "schema":      map[string]interface{}{"type": "string", "enum": []string{"kp", "tmdb"}},
+                            "description": "Источник: kp или tmdb",
+                        },
 						{
 							"name":        "page",
 							"in":          "query",
@@ -208,7 +223,7 @@ func getOpenAPISpecWithURL(baseURL string) *OpenAPISpec {
 					},
 					"responses": map[string]interface{}{
 						"200": map[string]interface{}{
-							"description": "Результаты поиска",
+                            "description": "Результаты поиска (унифицированные)",
 						},
 					},
 				},
@@ -327,123 +342,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/images.go

@@ -1,15 +1,17 @@
 package handlers
 
 import (
-	"fmt"
+    "fmt"
-	"io"
+    "io"
-	"net/http"
+    "net/http"
-	"os"
+    "net/url"
-	"path/filepath"
+    "os"
-	"strings"
+    "path/filepath"
+    "strings"
+    "time"
 
-	"github.com/gorilla/mux"
+    "github.com/gorilla/mux"
-	"neomovies-api/pkg/config"
+    "neomovies-api/pkg/config"
 )
 
 type ImagesHandler struct{}
@@ -26,7 +28,13 @@ func (h *ImagesHandler) GetImage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	if imagePath == "placeholder.jpg" {
+    // Попробуем декодировать путь заранее (на фронте абсолютные URL передаются как encodeURIComponent)
+    decodedPath := imagePath
+    if dp, err := url.QueryUnescape(imagePath); err == nil {
+        decodedPath = dp
+    }
+
+    if imagePath == "placeholder.jpg" || decodedPath == "placeholder.jpg" {
 		h.servePlaceholder(w, r)
 		return
 	}
@@ -36,14 +44,85 @@ func (h *ImagesHandler) GetImage(w http.ResponseWriter, r *http.Request) {
 		size = "original"
 	}
 
-	imageURL := fmt.Sprintf("%s/%s/%s", config.TMDBImageBaseURL, size, imagePath)
+    var imageURL string
+    // Нормализуем абсолютные ссылки вида "https:/..." → "https://...", а также "//..." → "https://..."
+    normalized := decodedPath
+    if strings.HasPrefix(normalized, "//") {
+        normalized = "https:" + normalized
+    }
+    if strings.HasPrefix(normalized, "http:/") && !strings.HasPrefix(normalized, "http://") {
+        normalized = strings.Replace(normalized, "http:/", "http://", 1)
+    }
+    if strings.HasPrefix(normalized, "https:/") && !strings.HasPrefix(normalized, "https://") {
+        normalized = strings.Replace(normalized, "https:/", "https://", 1)
+    }
 
-	resp, err := http.Get(imageURL)
+    if strings.HasPrefix(normalized, "http://") || strings.HasPrefix(normalized, "https://") {
+        // Проксируем внешний абсолютный URL (например, Kinopoisk)
+        imageURL = normalized
+    } else {
+        // TMDB относительный путь
+        imageURL = fmt.Sprintf("%s/%s/%s", config.TMDBImageBaseURL, size, imagePath)
+    }
+
+    client := &http.Client{Timeout: 12 * time.Second}
+
+    // Подготовим несколько вариантов заголовков для обхода ограничений источников
+    buildRequest := func(targetURL string, attempt int) (*http.Request, error) {
+        req, err := http.NewRequest("GET", targetURL, nil)
+        if err != nil {
+            return nil, err
+        }
+        // Универсальные заголовки как у браузера
+        req.Header.Set("Accept", "image/avif,image/webp,image/apng,image/*,*/*;q=0.8")
+        req.Header.Set("Accept-Language", "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7")
+        if ua := r.Header.Get("User-Agent"); ua != "" {
+            req.Header.Set("User-Agent", ua)
+        } else {
+            req.Header.Set("User-Agent", "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0 Safari/537.36")
+        }
+
+        // Настройка Referer: для Yandex/Kinopoisk ставим kinopoisk.ru, иначе — origin URL
+        parsed, _ := url.Parse(targetURL)
+        host := strings.ToLower(parsed.Host)
+        switch attempt {
+        case 0:
+            if strings.Contains(host, "kinopoisk") || strings.Contains(host, "yandex") {
+                req.Header.Set("Referer", "https://www.kinopoisk.ru/")
+            } else if parsed.Scheme != "" && parsed.Host != "" {
+                req.Header.Set("Referer", parsed.Scheme+"://"+parsed.Host+"/")
+            }
+        case 1:
+            // Без Referer
+        default:
+            // Оставляем как есть
+        }
+
+        return req, nil
+    }
+
+    // До 2-х попыток: с реферером источника и без реферера
+    var resp *http.Response
+    var err error
+    for attempt := 0; attempt < 2; attempt++ {
+        var req *http.Request
+        req, err = buildRequest(imageURL, attempt)
+        if err != nil {
+            continue
+        }
+        resp, err = client.Do(req)
+        if err == nil && resp != nil && resp.StatusCode == http.StatusOK {
+            break
+        }
+        if resp != nil {
+            resp.Body.Close()
+        }
+    }
 	if err != nil {
 		h.servePlaceholder(w, r)
 		return
 	}
-	defer resp.Body.Close()
+    defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {
 		h.servePlaceholder(w, r)

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

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"strconv"
+	"strings"
 
 	"github.com/gorilla/mux"
 
@@ -29,7 +30,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)
 
@@ -48,15 +49,41 @@ func (h *MovieHandler) Search(w http.ResponseWriter, r *http.Request) {
 
 func (h *MovieHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["id"])
+	rawID := vars["id"]
-	if err != nil {
+
-		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+	// Support formats: "123" (old), "kp_123", "tmdb_123"
-		return
+	source := ""
+	var id int
+	if strings.Contains(rawID, "_") {
+		parts := strings.SplitN(rawID, "_", 2)
+		if len(parts) != 2 {
+			http.Error(w, "Invalid ID format", http.StatusBadRequest)
+			return
+		}
+		source = parts[0]
+		parsed, err := strconv.Atoi(parts[1])
+		if err != nil {
+			http.Error(w, "Invalid numeric ID", http.StatusBadRequest)
+			return
+		}
+		id = parsed
+	} else {
+		// Backward compatibility
+		parsed, err := strconv.Atoi(rawID)
+		if err != nil {
+			http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+			return
+		}
+		id = parsed
 	}
 
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
+	idType := r.URL.Query().Get("id_type")
+	if source == "kp" || source == "tmdb" {
+		idType = source
+	}
 
-	movie, err := h.movieService.GetByID(id, language)
+	movie, err := h.movieService.GetByID(id, language, idType)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -71,7 +98,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 +116,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 +134,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 +152,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 +177,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 +201,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

@@ -30,16 +30,23 @@ func (h *PlayersHandler) GetAllohaPlayer(w http.ResponseWriter, r *http.Request)
 	log.Printf("GetAllohaPlayer called: %s %s", r.Method, r.URL.Path)
 
 	vars := mux.Vars(r)
-	log.Printf("Route vars: %+v", vars)
+    idType := vars["id_type"]
+	id := vars["id"]
 
-	imdbID := vars["imdb_id"]
+	if idType == "" || id == "" {
-	if imdbID == "" {
+		log.Printf("Error: id_type or id is empty")
-		log.Printf("Error: imdb_id is empty")
+		http.Error(w, "id_type and id are required", http.StatusBadRequest)
-		http.Error(w, "imdb_id path param is required", http.StatusBadRequest)
 		return
 	}
 
-	log.Printf("Processing imdb_id: %s", imdbID)
+    if idType == "kinopoisk_id" { idType = "kp" }
+    if idType != "kp" && idType != "imdb" {
+		log.Printf("Error: invalid id_type: %s", idType)
+        http.Error(w, "id_type must be 'kp' (kinopoisk_id) or 'imdb'", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing %s ID: %s", idType, id)
 
 	if h.config.AllohaToken == "" {
 		log.Printf("Error: ALLOHA_TOKEN is missing")
@@ -47,7 +54,7 @@ func (h *PlayersHandler) GetAllohaPlayer(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	idParam := fmt.Sprintf("imdb=%s", url.QueryEscape(imdbID))
+	idParam := fmt.Sprintf("%s=%s", idType, url.QueryEscape(id))
 	apiURL := fmt.Sprintf("https://api.alloha.tv/?token=%s&%s", h.config.AllohaToken, idParam)
 	log.Printf("Calling Alloha API: %s", apiURL)
 
@@ -94,9 +101,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)
@@ -108,40 +136,170 @@ func (h *PlayersHandler) GetAllohaPlayer(w http.ResponseWriter, r *http.Request)
 	w.Header().Set("Content-Type", "text/html")
 	w.Write([]byte(htmlDoc))
 
-	log.Printf("Successfully served Alloha player for imdb_id: %s", imdbID)
+	log.Printf("Successfully served Alloha player for %s: %s", idType, id)
 }
 
 func (h *PlayersHandler) GetLumexPlayer(w http.ResponseWriter, r *http.Request) {
 	log.Printf("GetLumexPlayer called: %s %s", r.Method, r.URL.Path)
 
 	vars := mux.Vars(r)
-	log.Printf("Route vars: %+v", vars)
+	idType := vars["id_type"]
+	id := vars["id"]
 
-	imdbID := vars["imdb_id"]
+	if idType == "" || id == "" {
-	if imdbID == "" {
+		log.Printf("Error: id_type or id is empty")
-		log.Printf("Error: imdb_id is empty")
+		http.Error(w, "id_type and id are required", http.StatusBadRequest)
-		http.Error(w, "imdb_id path param is required", http.StatusBadRequest)
 		return
 	}
 
-	log.Printf("Processing imdb_id: %s", imdbID)
+    // Поддержка алиаса
-
+    if idType == "kinopoisk_id" { idType = "kp" }
-	if h.config.LumexURL == "" {
+    if idType != "kp" && idType != "imdb" {
-		log.Printf("Error: LUMEX_URL is missing")
+		log.Printf("Error: invalid id_type: %s", idType)
-		http.Error(w, "Server misconfiguration: LUMEX_URL missing", http.StatusInternalServerError)
+		http.Error(w, "id_type must be 'kp' or 'imdb'", http.StatusBadRequest)
 		return
 	}
 
-	url := fmt.Sprintf("%s?imdb_id=%s", h.config.LumexURL, url.QueryEscape(imdbID))
+	log.Printf("Processing %s ID: %s", idType, id)
-	log.Printf("Generated Lumex URL: %s", url)
 
-	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, url)
+    if h.config.LumexURL == "" {
+        log.Printf("Error: LUMEX_URL is missing")
+        http.Error(w, "Server misconfiguration: LUMEX_URL missing", http.StatusInternalServerError)
+        return
+    }
+
+    // Встраивание напрямую через p.lumex.cloud: <iframe src="//p.lumex.cloud/<code>?kp_id=...">
+    // Ожидается, что LUMEX_URL задаёт базу вида: https://p.lumex.cloud/<code>
+    var paramName string
+    if idType == "kp" {
+        paramName = "kp_id"
+    } else {
+        paramName = "imdb_id"
+    }
+
+    separator := "?"
+    if strings.Contains(h.config.LumexURL, "?") {
+        separator = "&"
+    }
+    playerURL := fmt.Sprintf("%s%s%s=%s", h.config.LumexURL, separator, paramName, url.QueryEscape(id))
+	log.Printf("Lumex URL: %s", playerURL)
+
+	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")
 	w.Write([]byte(htmlDoc))
 
-	log.Printf("Successfully served Lumex player for imdb_id: %s", imdbID)
+	log.Printf("Successfully served Lumex player for %s: %s", idType, id)
+}
+
+func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetVibixPlayer called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	idType := vars["id_type"]
+	id := vars["id"]
+
+	if idType == "" || id == "" {
+		log.Printf("Error: id_type or id is empty")
+		http.Error(w, "id_type and id are required", http.StatusBadRequest)
+		return
+	}
+
+	if idType != "kp" && idType != "imdb" {
+		log.Printf("Error: invalid id_type: %s", idType)
+		http.Error(w, "id_type must be 'kp' or 'imdb'", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing %s ID: %s", idType, id)
+
+	if h.config.VibixToken == "" {
+		log.Printf("Error: VIBIX_TOKEN is missing")
+		http.Error(w, "Server misconfiguration: VIBIX_TOKEN missing", http.StatusInternalServerError)
+		return
+	}
+
+	vibixHost := h.config.VibixHost
+	if vibixHost == "" {
+		vibixHost = "https://vibix.org"
+	}
+
+	var endpoint string
+	if idType == "kp" {
+		endpoint = "kinopoisk"
+	} else {
+		endpoint = "imdb"
+	}
+
+	apiURL := fmt.Sprintf("%s/api/v1/publisher/videos/%s/%s", vibixHost, endpoint, id)
+	log.Printf("Calling Vibix API: %s", apiURL)
+
+	req, err := http.NewRequest("GET", apiURL, nil)
+	if err != nil {
+		log.Printf("Error creating Vibix request: %v", err)
+		http.Error(w, "Failed to create request", http.StatusInternalServerError)
+		return
+	}
+
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Authorization", h.config.VibixToken)
+	req.Header.Set("X-CSRF-TOKEN", "")
+
+	client := &http.Client{Timeout: 8 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		log.Printf("Error calling Vibix API: %v", err)
+		http.Error(w, "Failed to fetch from Vibix API", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	log.Printf("Vibix API response status: %d", resp.StatusCode)
+
+	if resp.StatusCode != http.StatusOK {
+		log.Printf("Vibix API error: %d", resp.StatusCode)
+		http.Error(w, fmt.Sprintf("Vibix API error: %d", resp.StatusCode), http.StatusBadGateway)
+		return
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("Error reading Vibix response: %v", err)
+		http.Error(w, "Failed to read Vibix response", http.StatusInternalServerError)
+		return
+	}
+
+	log.Printf("Vibix API response body: %s", string(body))
+
+	var vibixResponse struct {
+		ID        interface{} `json:"id"`
+		IframeURL string      `json:"iframe_url"`
+	}
+
+	if err := json.Unmarshal(body, &vibixResponse); err != nil {
+		log.Printf("Error unmarshaling Vibix JSON: %v", err)
+		http.Error(w, "Invalid JSON from Vibix", http.StatusBadGateway)
+		return
+	}
+
+	if vibixResponse.ID == nil || vibixResponse.IframeURL == "" {
+		log.Printf("Video not found or empty iframe_url")
+		http.Error(w, "Video not found", http.StatusNotFound)
+		return
+	}
+
+	// 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>`, 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")
+	w.Write([]byte(htmlDoc))
+
+	log.Printf("Successfully served Vibix player for %s: %s", idType, id)
 }
 
 // GetRgShowsPlayer handles RgShows streaming requests
@@ -341,3 +499,228 @@ func (h *PlayersHandler) GetStreamAPI(w http.ResponseWriter, r *http.Request) {
 
 	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) GetHDVBPlayer(w http.ResponseWriter, r *http.Request) {
+	log.Printf("GetHDVBPlayer called: %s %s", r.Method, r.URL.Path)
+
+	vars := mux.Vars(r)
+	idType := vars["id_type"]
+	id := vars["id"]
+
+	if idType == "" || id == "" {
+		log.Printf("Error: id_type or id is empty")
+		http.Error(w, "id_type and id are required", http.StatusBadRequest)
+		return
+	}
+
+	if idType != "kp" && idType != "imdb" {
+		log.Printf("Error: invalid id_type: %s", idType)
+		http.Error(w, "id_type must be 'kp' or 'imdb'", http.StatusBadRequest)
+		return
+	}
+
+	log.Printf("Processing %s ID: %s", idType, id)
+
+	if h.config.HDVBToken == "" {
+		log.Printf("Error: HDVB_TOKEN is missing")
+		http.Error(w, "Server misconfiguration: HDVB_TOKEN missing", http.StatusInternalServerError)
+		return
+	}
+
+	var apiURL string
+	if idType == "kp" {
+		apiURL = fmt.Sprintf("https://apivb.com/api/videos.json?id_kp=%s&token=%s", id, h.config.HDVBToken)
+	} else {
+		apiURL = fmt.Sprintf("https://apivb.com/api/videos.json?imdb_id=%s&token=%s", id, h.config.HDVBToken)
+	}
+	log.Printf("HDVB API URL: %s", apiURL)
+
+	resp, err := http.Get(apiURL)
+	if err != nil {
+		log.Printf("Error fetching HDVB data: %v", err)
+		http.Error(w, "Failed to fetch player data", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("Error reading HDVB response: %v", err)
+		http.Error(w, "Failed to read player data", http.StatusInternalServerError)
+		return
+	}
+
+	var hdvbData []map[string]interface{}
+	if err := json.Unmarshal(body, &hdvbData); err != nil {
+		log.Printf("Error parsing HDVB JSON: %v, body: %s", err, string(body))
+		http.Error(w, "Failed to parse player data", http.StatusInternalServerError)
+		return
+	}
+
+	if len(hdvbData) == 0 {
+		log.Printf("No HDVB data found for ID: %s", id)
+		http.Error(w, "No player data found", http.StatusNotFound)
+		return
+	}
+
+	iframeURL, ok := hdvbData[0]["iframe_url"].(string)
+	if !ok || iframeURL == "" {
+		log.Printf("No iframe_url in HDVB response for ID: %s", id)
+		http.Error(w, "No player URL found", http.StatusNotFound)
+		return
+	}
+
+	log.Printf("HDVB iframe URL: %s", iframeURL)
+
+	iframe := fmt.Sprintf(`<iframe src="%s" allowfullscreen loading="lazy" style="border:none;width:100%%;height:100%%;"></iframe>`, iframeURL)
+	htmlDoc := fmt.Sprintf(`<!DOCTYPE html><html><head><meta charset='utf-8'/><title>HDVB 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 HDVB player for %s: %s", idType, 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

@@ -10,11 +10,13 @@ import (
 
 type SearchHandler struct {
 	tmdbService *services.TMDBService
+	kpService   *services.KinopoiskService
 }
 
-func NewSearchHandler(tmdbService *services.TMDBService) *SearchHandler {
+func NewSearchHandler(tmdbService *services.TMDBService, kpService *services.KinopoiskService) *SearchHandler {
 	return &SearchHandler{
 		tmdbService: tmdbService,
+		kpService:   kpService,
 	}
 }
 
@@ -26,20 +28,62 @@ 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 services.ShouldUseKinopoisk(language) {
-	if err != nil {
+        if h.kpService == nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
+            http.Error(w, "Kinopoisk service is not configured", http.StatusBadGateway)
-		return
+            return
-	}
+        }
 
-	w.Header().Set("Content-Type", "application/json")
+        kpSearch, err := h.kpService.SearchFilms(query, page)
-	json.NewEncoder(w).Encode(models.APIResponse{
+        if err != nil {
-		Success: true,
+            http.Error(w, err.Error(), http.StatusBadGateway)
-		Data:    results,
+            return
-	})
+        }
+
+        tmdbResp := services.MapKPSearchToTMDBResponse(kpSearch)
+        multiResults := make([]models.MultiSearchResult, 0)
+        for _, movie := range tmdbResp.Results {
+            multiResults = append(multiResults, models.MultiSearchResult{
+                ID:               movie.ID,
+                MediaType:        "movie",
+                Title:            movie.Title,
+                OriginalTitle:    movie.OriginalTitle,
+                Overview:         movie.Overview,
+                PosterPath:       movie.PosterPath,
+                BackdropPath:     movie.BackdropPath,
+                ReleaseDate:      movie.ReleaseDate,
+                VoteAverage:      movie.VoteAverage,
+                VoteCount:        movie.VoteCount,
+                Popularity:       movie.Popularity,
+                Adult:            movie.Adult,
+                OriginalLanguage: movie.OriginalLanguage,
+            })
+        }
+        w.Header().Set("Content-Type", "application/json")
+        json.NewEncoder(w).Encode(models.APIResponse{
+            Success: true,
+            Data: models.MultiSearchResponse{
+                Page:         page,
+                Results:      multiResults,
+                TotalPages:   tmdbResp.TotalPages,
+                TotalResults: tmdbResp.TotalResults,
+            },
+        })
+        return
+    }
+
+    // EN/прочие языки — TMDB
+    results, err := h.tmdbService.SearchMulti(query, page, language)
+    if err != nil {
+        http.Error(w, err.Error(), http.StatusInternalServerError)
+        return
+    }
+
+    w.Header().Set("Content-Type", "application/json")
+    json.NewEncoder(w).Encode(models.APIResponse{
+        Success: true,
+        Data:    results,
+    })
 }

pkg/handlers/tv.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 	"strconv"
+	"strings"
 
 	"github.com/gorilla/mux"
 
@@ -29,7 +30,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)
@@ -47,15 +48,41 @@ func (h *TVHandler) Search(w http.ResponseWriter, r *http.Request) {
 
 func (h *TVHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 	vars := mux.Vars(r)
-	id, err := strconv.Atoi(vars["id"])
+	rawID := vars["id"]
-	if err != nil {
+
-		http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+	// Support formats: "123" (old), "kp_123", "tmdb_123"
-		return
+	source := ""
+	var id int
+	if strings.Contains(rawID, "_") {
+		parts := strings.SplitN(rawID, "_", 2)
+		if len(parts) != 2 {
+			http.Error(w, "Invalid ID format", http.StatusBadRequest)
+			return
+		}
+		source = parts[0]
+		parsed, err := strconv.Atoi(parts[1])
+		if err != nil {
+			http.Error(w, "Invalid numeric ID", http.StatusBadRequest)
+			return
+		}
+		id = parsed
+	} else {
+		// Backward compatibility
+		parsed, err := strconv.Atoi(rawID)
+		if err != nil {
+			http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+			return
+		}
+		id = parsed
 	}
 
-	language := r.URL.Query().Get("language")
+	language := GetLanguage(r)
+	idType := r.URL.Query().Get("id_type")
+	if source == "kp" || source == "tmdb" {
+		idType = source
+	}
 
-	tvShow, err := h.tvService.GetByID(id, language)
+	tvShow, err := h.tvService.GetByID(id, language, idType)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)
 		return
@@ -70,7 +97,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 +114,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 +131,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 +148,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 +172,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 +196,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/handlers/unified.go

@@ -0,0 +1,228 @@
+package handlers
+
+import (
+    "encoding/json"
+    "net/http"
+    "strconv"
+    "strings"
+    "time"
+
+    "neomovies-api/pkg/models"
+    "neomovies-api/pkg/services"
+)
+
+type UnifiedHandler struct {
+    tmdb *services.TMDBService
+    kp   *services.KinopoiskService
+}
+
+func NewUnifiedHandler(tmdb *services.TMDBService, kp *services.KinopoiskService) *UnifiedHandler {
+    return &UnifiedHandler{tmdb: tmdb, kp: kp}
+}
+
+// Parse source ID of form "kp_123" or "tmdb_456"
+func parseSourceID(raw string) (source string, id int, err error) {
+    parts := strings.SplitN(raw, "_", 2)
+    if len(parts) != 2 {
+        return "", 0, strconv.ErrSyntax
+    }
+    src := strings.ToLower(parts[0])
+    if src != "kp" && src != "tmdb" {
+        return "", 0, strconv.ErrSyntax
+    }
+    num, err := strconv.Atoi(parts[1])
+    if err != nil {
+        return "", 0, err
+    }
+    return src, num, nil
+}
+
+func (h *UnifiedHandler) GetMovie(w http.ResponseWriter, r *http.Request) {
+    start := time.Now()
+    vars := muxVars(r)
+    rawID := vars["id"]
+
+    source, id, err := parseSourceID(rawID)
+    if err != nil {
+        writeUnifiedError(w, http.StatusBadRequest, "invalid SOURCE_ID format", start, "")
+        return
+    }
+
+    language := GetLanguage(r)
+    var data *models.UnifiedContent
+    if source == "kp" {
+        if h.kp == nil {
+            writeUnifiedError(w, http.StatusBadGateway, "Kinopoisk service not configured", start, source)
+            return
+        }
+        kpFilm, err := h.kp.GetFilmByKinopoiskId(id)
+        if err != nil {
+            writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+            return
+        }
+        data = services.MapKPToUnified(kpFilm)
+        // Обогащаем только externalIds.tmdb через /find (берем только поле id)
+        if kpFilm.ImdbId != "" {
+            if tmdbID, fErr := h.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "movie", GetLanguage(r)); fErr == nil {
+                data.ExternalIDs.TMDB = &tmdbID
+            }
+        }
+    } else {
+        // tmdb
+        movie, err := h.tmdb.GetMovie(id, language)
+        if err != nil {
+            writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+            return
+        }
+        ext, _ := h.tmdb.GetMovieExternalIDs(id)
+        data = services.MapTMDBToUnifiedMovie(movie, ext)
+    }
+
+    writeUnifiedOK(w, data, start, source, "")
+}
+
+func (h *UnifiedHandler) GetTV(w http.ResponseWriter, r *http.Request) {
+    start := time.Now()
+    vars := muxVars(r)
+    rawID := vars["id"]
+
+    source, id, err := parseSourceID(rawID)
+    if err != nil {
+        writeUnifiedError(w, http.StatusBadRequest, "invalid SOURCE_ID format", start, "")
+        return
+    }
+
+    language := GetLanguage(r)
+    var data *models.UnifiedContent
+    if source == "kp" {
+        if h.kp == nil {
+            writeUnifiedError(w, http.StatusBadGateway, "Kinopoisk service not configured", start, source)
+            return
+        }
+        kpFilm, err := h.kp.GetFilmByKinopoiskId(id)
+        if err != nil {
+            writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+            return
+        }
+        data = services.MapKPToUnified(kpFilm)
+        if kpFilm.ImdbId != "" {
+            if tmdbID, fErr := h.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "tv", GetLanguage(r)); fErr == nil {
+                data.ExternalIDs.TMDB = &tmdbID
+            }
+        }
+    } else {
+        tv, err := h.tmdb.GetTVShow(id, language)
+        if err != nil {
+            writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+            return
+        }
+        ext, _ := h.tmdb.GetTVExternalIDs(id)
+        data = services.MapTMDBTVToUnified(tv, ext)
+    }
+
+    writeUnifiedOK(w, data, start, source, "")
+}
+
+func (h *UnifiedHandler) Search(w http.ResponseWriter, r *http.Request) {
+    start := time.Now()
+    query := r.URL.Query().Get("query")
+    if strings.TrimSpace(query) == "" {
+        writeUnifiedError(w, http.StatusBadRequest, "query is required", start, "")
+        return
+    }
+    source := strings.ToLower(r.URL.Query().Get("source")) // kp|tmdb
+    page := getIntQuery(r, "page", 1)
+    language := GetLanguage(r)
+
+    if source != "kp" && source != "tmdb" {
+        writeUnifiedError(w, http.StatusBadRequest, "source must be 'kp' or 'tmdb'", start, "")
+        return
+    }
+
+    if source == "kp" {
+        if h.kp == nil {
+            writeUnifiedError(w, http.StatusBadGateway, "Kinopoisk service not configured", start, source)
+            return
+        }
+        kpSearch, err := h.kp.SearchFilms(query, page)
+        if err != nil {
+            writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+            return
+        }
+        items := services.MapKPSearchToUnifiedItems(kpSearch)
+        // Обогащаем результаты поиска TMDB ID через получение полной информации о фильмах
+        if h.tmdb != nil {
+            for i := range items {
+                if kpID, err := strconv.Atoi(items[i].ID); err == nil {
+                    if kpFilm, err := h.kp.GetFilmByKinopoiskId(kpID); err == nil && kpFilm.ImdbId != "" {
+                        items[i].ExternalIDs.IMDb = kpFilm.ImdbId
+                        mediaType := "movie"
+                        if items[i].Type == "tv" {
+                            mediaType = "tv"
+                        }
+                        if tmdbID, err := h.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, mediaType, "ru-RU"); err == nil {
+                            items[i].ExternalIDs.TMDB = &tmdbID
+                        }
+                    }
+                }
+            }
+        }
+        resp := models.UnifiedSearchResponse{
+            Success: true,
+            Data:    items,
+            Source:  source,
+            Pagination: models.UnifiedPagination{Page: page, TotalPages: kpSearch.PagesCount, TotalResults: kpSearch.SearchFilmsCountResult, PageSize: len(items)},
+            Metadata: models.UnifiedMetadata{FetchedAt: time.Now(), APIVersion: "3.0", ResponseTime: time.Since(start).Milliseconds(), Query: query},
+        }
+        writeJSON(w, http.StatusOK, resp)
+        return
+    }
+
+    // TMDB multi search
+    multi, err := h.tmdb.SearchMulti(query, page, language)
+    if err != nil {
+        writeUnifiedError(w, http.StatusBadGateway, err.Error(), start, source)
+        return
+    }
+    items := services.MapTMDBMultiToUnifiedItems(multi)
+    resp := models.UnifiedSearchResponse{
+        Success: true,
+        Data:    items,
+        Source:  source,
+        Pagination: models.UnifiedPagination{Page: multi.Page, TotalPages: multi.TotalPages, TotalResults: multi.TotalResults, PageSize: len(items)},
+        Metadata: models.UnifiedMetadata{FetchedAt: time.Now(), APIVersion: "3.0", ResponseTime: time.Since(start).Milliseconds(), Query: query},
+    }
+    writeJSON(w, http.StatusOK, resp)
+}
+
+func writeUnifiedOK(w http.ResponseWriter, data *models.UnifiedContent, start time.Time, source string, query string) {
+    resp := models.UnifiedAPIResponse{
+        Success: true,
+        Data:    data,
+        Source:  source,
+        Metadata: models.UnifiedMetadata{
+            FetchedAt:    time.Now(),
+            APIVersion:   "3.0",
+            ResponseTime: time.Since(start).Milliseconds(),
+            Query:        query,
+        },
+    }
+    w.Header().Set("Content-Type", "application/json")
+    json.NewEncoder(w).Encode(resp)
+}
+
+func writeUnifiedError(w http.ResponseWriter, code int, message string, start time.Time, source string) {
+    resp := models.UnifiedAPIResponse{
+        Success: false,
+        Error:   message,
+        Source:  source,
+        Metadata: models.UnifiedMetadata{
+            FetchedAt:    time.Now(),
+            APIVersion:   "3.0",
+            ResponseTime: time.Since(start).Milliseconds(),
+        },
+    }
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(code)
+    json.NewEncoder(w).Encode(resp)
+}

pkg/handlers/unified_helpers.go

@@ -0,0 +1,23 @@
+package handlers
+
+import (
+    "encoding/json"
+    "net/http"
+    "time"
+
+    "github.com/gorilla/mux"
+)
+
+func muxVars(r *http.Request) map[string]string { return mux.Vars(r) }
+
+func writeJSON(w http.ResponseWriter, status int, v interface{}) {
+    w.Header().Set("Content-Type", "application/json")
+    w.WriteHeader(status)
+    _ = json.NewEncoder(w).Encode(v)
+}
+
+type metaEnvelope struct {
+    FetchedAt    time.Time `json:"fetchedAt"`
+    APIVersion   string    `json:"apiVersion"`
+    ResponseTime int64     `json:"responseTime"`
+}

pkg/models/movie.go

@@ -40,6 +40,7 @@ type Movie struct {
 	Tagline             string              `json:"tagline,omitempty"`
 	Homepage            string              `json:"homepage,omitempty"`
 	IMDbID              string              `json:"imdb_id,omitempty"`
+	KinopoiskID         int                 `json:"kinopoisk_id,omitempty"`
 	BelongsToCollection *Collection         `json:"belongs_to_collection,omitempty"`
 	ProductionCompanies []ProductionCompany `json:"production_companies,omitempty"`
 	ProductionCountries []ProductionCountry `json:"production_countries,omitempty"`
@@ -76,6 +77,8 @@ type TVShow struct {
 	CreatedBy           []Creator           `json:"created_by,omitempty"`
 	EpisodeRunTime      []int               `json:"episode_run_time,omitempty"`
 	Seasons             []Season            `json:"seasons,omitempty"`
+	IMDbID              string              `json:"imdb_id,omitempty"`
+	KinopoiskID         int                 `json:"kinopoisk_id,omitempty"`
 }
 
 // MultiSearchResult для мультипоиска
@@ -119,6 +122,8 @@ type GenresResponse struct {
 type ExternalIDs struct {
 	ID          int    `json:"id"`
 	IMDbID      string `json:"imdb_id"`
+	KinopoiskID int    `json:"kinopoisk_id,omitempty"`
+	TMDBID      int    `json:"tmdb_id,omitempty"`
 	TVDBID      int    `json:"tvdb_id,omitempty"`
 	WikidataID  string `json:"wikidata_id"`
 	FacebookID  string `json:"facebook_id"`

pkg/models/unified.go

@@ -0,0 +1,114 @@
+package models
+
+import "time"
+
+// Unified entities and response envelopes for prefixed-source API
+
+type UnifiedGenre struct {
+    ID   string `json:"id"`
+    Name string `json:"name"`
+}
+
+type UnifiedCastMember struct {
+    ID        string `json:"id"`
+    Name      string `json:"name"`
+    Character string `json:"character,omitempty"`
+}
+
+type UnifiedExternalIDs struct {
+    KP   *int   `json:"kp"`
+    TMDB *int   `json:"tmdb"`
+    IMDb string `json:"imdb"`
+}
+
+type UnifiedContent struct {
+    ID            string              `json:"id"`
+    SourceID      string              `json:"sourceId"`
+    Title         string              `json:"title"`
+    OriginalTitle string              `json:"originalTitle"`
+    Description   string              `json:"description"`
+    ReleaseDate   string              `json:"releaseDate"`
+    EndDate       *string             `json:"endDate"`
+    Type          string              `json:"type"` // movie | tv
+    Genres        []UnifiedGenre      `json:"genres"`
+    Rating        float64             `json:"rating"`
+    PosterURL     string              `json:"posterUrl"`
+    BackdropURL   string              `json:"backdropUrl"`
+    Director      string              `json:"director"`
+    Cast          []UnifiedCastMember `json:"cast"`
+    Duration      int                 `json:"duration"`
+    Country       string              `json:"country"`
+    Language      string              `json:"language"`
+    Budget        *int64              `json:"budget"`
+    Revenue       *int64              `json:"revenue"`
+    IMDbID        string              `json:"imdbId"`
+    ExternalIDs   UnifiedExternalIDs  `json:"externalIds"`
+    // For TV shows
+    Seasons       []UnifiedSeason     `json:"seasons,omitempty"`
+}
+
+type UnifiedSeason struct {
+    ID           string           `json:"id"`
+    SourceID     string           `json:"sourceId"`
+    Name         string           `json:"name"`
+    SeasonNumber int              `json:"seasonNumber"`
+    EpisodeCount int              `json:"episodeCount"`
+    ReleaseDate  string           `json:"releaseDate"`
+    PosterURL    string           `json:"posterUrl"`
+    Episodes     []UnifiedEpisode `json:"episodes,omitempty"`
+}
+
+type UnifiedEpisode struct {
+    ID           string `json:"id"`
+    SourceID     string `json:"sourceId"`
+    Name         string `json:"name"`
+    EpisodeNumber int   `json:"episodeNumber"`
+    SeasonNumber  int   `json:"seasonNumber"`
+    AirDate      string `json:"airDate"`
+    Duration     int    `json:"duration"`
+    Description  string `json:"description"`
+    StillURL     string `json:"stillUrl"`
+}
+
+type UnifiedSearchItem struct {
+    ID          string             `json:"id"`
+    SourceID    string             `json:"sourceId"`
+    Title       string             `json:"title"`
+    Type        string             `json:"type"`
+    OriginalType string            `json:"originalType,omitempty"`
+    ReleaseDate string             `json:"releaseDate"`
+    PosterURL   string             `json:"posterUrl"`
+    Rating      float64            `json:"rating"`
+    Description string             `json:"description"`
+    ExternalIDs UnifiedExternalIDs `json:"externalIds"`
+}
+
+type UnifiedPagination struct {
+    Page         int `json:"page"`
+    TotalPages   int `json:"totalPages"`
+    TotalResults int `json:"totalResults"`
+    PageSize     int `json:"pageSize"`
+}
+
+type UnifiedMetadata struct {
+    FetchedAt    time.Time `json:"fetchedAt"`
+    APIVersion   string    `json:"apiVersion"`
+    ResponseTime int64     `json:"responseTime"`
+    Query        string    `json:"query,omitempty"`
+}
+
+type UnifiedAPIResponse struct {
+    Success  bool            `json:"success"`
+    Data     interface{}     `json:"data,omitempty"`
+    Error    string          `json:"error,omitempty"`
+    Source   string          `json:"source,omitempty"`
+    Metadata UnifiedMetadata `json:"metadata"`
+}
+
+type UnifiedSearchResponse struct {
+    Success    bool                `json:"success"`
+    Data       []UnifiedSearchItem `json:"data"`
+    Source     string              `json:"source"`
+    Pagination UnifiedPagination   `json:"pagination"`
+    Metadata   UnifiedMetadata     `json:"metadata"`
+}

pkg/services/kinopoisk.go

@@ -0,0 +1,262 @@
+package services
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+type KinopoiskService struct {
+	apiKey  string
+	baseURL string
+	client  *http.Client
+}
+
+type KPFilm struct {
+	KinopoiskId        int      `json:"kinopoiskId"`
+	ImdbId             string   `json:"imdbId"`
+	NameRu             string   `json:"nameRu"`
+	NameEn             string   `json:"nameEn"`
+	NameOriginal       string   `json:"nameOriginal"`
+	PosterUrl          string   `json:"posterUrl"`
+	PosterUrlPreview   string   `json:"posterUrlPreview"`
+	CoverUrl           string   `json:"coverUrl"`
+	LogoUrl            string   `json:"logoUrl"`
+	ReviewsCount       int      `json:"reviewsCount"`
+	RatingGoodReview   float64  `json:"ratingGoodReview"`
+	RatingGoodReviewVoteCount int `json:"ratingGoodReviewVoteCount"`
+	RatingKinopoisk    float64  `json:"ratingKinopoisk"`
+	RatingKinopoiskVoteCount int `json:"ratingKinopoiskVoteCount"`
+	RatingImdb         float64  `json:"ratingImdb"`
+	RatingImdbVoteCount int     `json:"ratingImdbVoteCount"`
+	RatingFilmCritics  float64  `json:"ratingFilmCritics"`
+	RatingFilmCriticsVoteCount int `json:"ratingFilmCriticsVoteCount"`
+	RatingAwait        float64  `json:"ratingAwait"`
+	RatingAwaitCount   int      `json:"ratingAwaitCount"`
+	RatingRfCritics    float64  `json:"ratingRfCritics"`
+	RatingRfCriticsVoteCount int `json:"ratingRfCriticsVoteCount"`
+	WebUrl             string   `json:"webUrl"`
+	Year               int      `json:"year"`
+	FilmLength         int      `json:"filmLength"`
+	Slogan             string   `json:"slogan"`
+	Description        string   `json:"description"`
+	ShortDescription   string   `json:"shortDescription"`
+	EditorAnnotation   string   `json:"editorAnnotation"`
+	IsTicketsAvailable bool     `json:"isTicketsAvailable"`
+	ProductionStatus   string   `json:"productionStatus"`
+	Type               string   `json:"type"`
+	RatingMpaa         string   `json:"ratingMpaa"`
+	RatingAgeLimits    string   `json:"ratingAgeLimits"`
+	HasImax            bool     `json:"hasImax"`
+	Has3D              bool     `json:"has3d"`
+	LastSync           string   `json:"lastSync"`
+	Countries          []struct {
+		Country string `json:"country"`
+	} `json:"countries"`
+	Genres []struct {
+		Genre string `json:"genre"`
+	} `json:"genres"`
+	StartYear int `json:"startYear"`
+	EndYear   int `json:"endYear"`
+	Serial    bool `json:"serial"`
+	ShortFilm bool `json:"shortFilm"`
+	Completed bool `json:"completed"`
+}
+
+type KPSearchResponse struct {
+	Keyword    string    `json:"keyword"`
+	PagesCount int       `json:"pagesCount"`
+	Films      []KPFilmShort `json:"films"`
+	SearchFilmsCountResult int `json:"searchFilmsCountResult"`
+}
+
+type KPFilmShort struct {
+	FilmId       int      `json:"filmId"`
+	NameRu       string   `json:"nameRu"`
+	NameEn       string   `json:"nameEn"`
+	Type         string   `json:"type"`
+	Year         string   `json:"year"`
+	Description  string   `json:"description"`
+	FilmLength   string   `json:"filmLength"`
+	Countries    []KPCountry `json:"countries"`
+	Genres       []KPGenre   `json:"genres"`
+	Rating       string   `json:"rating"`
+	RatingVoteCount int   `json:"ratingVoteCount"`
+	PosterUrl    string   `json:"posterUrl"`
+	PosterUrlPreview string `json:"posterUrlPreview"`
+}
+
+type KPCountry struct {
+	Country string `json:"country"`
+}
+
+type KPGenre struct {
+	Genre string `json:"genre"`
+}
+
+type KPExternalSource struct {
+	Source string `json:"source"`
+	ID     string `json:"id"`
+}
+
+func NewKinopoiskService(apiKey, baseURL string) *KinopoiskService {
+	return &KinopoiskService{
+		apiKey:  apiKey,
+		baseURL: baseURL,
+		client:  &http.Client{Timeout: 10 * time.Second},
+	}
+}
+
+func (s *KinopoiskService) makeRequest(endpoint string, target interface{}) error {
+	req, err := http.NewRequest("GET", endpoint, nil)
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("X-API-KEY", s.apiKey)
+	req.Header.Set("Accept", "application/json")
+
+	resp, err := s.client.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("Kinopoisk API error: %d", resp.StatusCode)
+	}
+
+	return json.NewDecoder(resp.Body).Decode(target)
+}
+
+func (s *KinopoiskService) GetFilmByKinopoiskId(id int) (*KPFilm, error) {
+	endpoint := fmt.Sprintf("%s/v2.2/films/%d", s.baseURL, id)
+	var film KPFilm
+	err := s.makeRequest(endpoint, &film)
+	return &film, err
+}
+
+func (s *KinopoiskService) GetFilmByImdbId(imdbId string) (*KPFilm, error) {
+    endpoint := fmt.Sprintf("%s/v2.2/films?imdbId=%s", s.baseURL, url.QueryEscape(imdbId))
+	
+	var response struct {
+		Films []KPFilm `json:"items"`
+	}
+	
+	err := s.makeRequest(endpoint, &response)
+	if err != nil {
+		return nil, err
+	}
+	
+	if len(response.Films) == 0 {
+		return nil, fmt.Errorf("film not found")
+	}
+	
+	return &response.Films[0], nil
+}
+
+func (s *KinopoiskService) SearchFilms(keyword string, page int) (*KPSearchResponse, error) {
+    endpoint := fmt.Sprintf("%s/v2.1/films/search-by-keyword?keyword=%s&page=%d", s.baseURL, url.QueryEscape(keyword), page)
+	var response KPSearchResponse
+	err := s.makeRequest(endpoint, &response)
+	return &response, err
+}
+
+func (s *KinopoiskService) GetExternalSources(kinopoiskId int) ([]KPExternalSource, error) {
+	endpoint := fmt.Sprintf("%s/v2.2/films/%d/external_sources", s.baseURL, kinopoiskId)
+	
+	var response struct {
+		Items []KPExternalSource `json:"items"`
+	}
+	
+	err := s.makeRequest(endpoint, &response)
+	if err != nil {
+		return nil, err
+	}
+	
+	return response.Items, nil
+}
+
+func (s *KinopoiskService) GetTopFilms(topType string, page int) (*KPSearchResponse, error) {
+	endpoint := fmt.Sprintf("%s/v2.2/films/top?type=%s&page=%d", s.baseURL, topType, page)
+	
+	var response struct {
+		PagesCount int           `json:"pagesCount"`
+		Films      []KPFilmShort `json:"films"`
+	}
+	
+	err := s.makeRequest(endpoint, &response)
+	if err != nil {
+		return nil, err
+	}
+	
+	return &KPSearchResponse{
+		PagesCount: response.PagesCount,
+		Films:      response.Films,
+		SearchFilmsCountResult: len(response.Films),
+	}, nil
+}
+
+func KPIdToImdbId(kpService *KinopoiskService, kpId int) (string, error) {
+	film, err := kpService.GetFilmByKinopoiskId(kpId)
+	if err != nil {
+		return "", err
+	}
+	return film.ImdbId, nil
+}
+
+func ImdbIdToKPId(kpService *KinopoiskService, imdbId string) (int, error) {
+	film, err := kpService.GetFilmByImdbId(imdbId)
+	if err != nil {
+		return 0, err
+	}
+	return film.KinopoiskId, nil
+}
+
+func TmdbIdToKPId(tmdbService *TMDBService, kpService *KinopoiskService, tmdbId int) (int, error) {
+	externalIds, err := tmdbService.GetMovieExternalIDs(tmdbId)
+	if err != nil {
+		return 0, err
+	}
+	
+	if externalIds.IMDbID == "" {
+		return 0, fmt.Errorf("no IMDb ID found for TMDB ID %d", tmdbId)
+	}
+	
+	return ImdbIdToKPId(kpService, externalIds.IMDbID)
+}
+
+func KPIdToTmdbId(tmdbService *TMDBService, kpService *KinopoiskService, kpId int) (int, error) {
+	imdbId, err := KPIdToImdbId(kpService, kpId)
+	if err != nil {
+		return 0, err
+	}
+	
+	movies, err := tmdbService.SearchMovies("", 1, "en-US", "", 0)
+	if err != nil {
+		return 0, err
+	}
+	
+	for _, movie := range movies.Results {
+		ids, err := tmdbService.GetMovieExternalIDs(movie.ID)
+		if err != nil {
+			continue
+		}
+		if ids.IMDbID == imdbId {
+			return movie.ID, nil
+		}
+	}
+	
+	return 0, fmt.Errorf("TMDB ID not found for KP ID %d", kpId)
+}
+
+func ConvertKPRating(rating float64) float64 {
+	return rating
+}
+
+func FormatKPYear(year int) string {
+	return strconv.Itoa(year)
+}

pkg/services/kp_mapper.go

@@ -0,0 +1,424 @@
+package services
+
+import (
+    "fmt"
+    "strconv"
+    "strings"
+    "time"
+
+    "neomovies-api/pkg/models"
+)
+
+func MapKPFilmToTMDBMovie(kpFilm *KPFilm) *models.Movie {
+	if kpFilm == nil {
+		return nil
+	}
+
+	releaseDate := ""
+	if kpFilm.Year > 0 {
+		releaseDate = fmt.Sprintf("%d-01-01", kpFilm.Year)
+	}
+
+	genres := make([]models.Genre, 0)
+	for _, g := range kpFilm.Genres {
+		genres = append(genres, models.Genre{
+			ID:   0,
+			Name: g.Genre,
+		})
+	}
+
+	countries := make([]models.ProductionCountry, 0)
+	for _, c := range kpFilm.Countries {
+		countries = append(countries, models.ProductionCountry{
+			ISO31661: "",
+			Name:     c.Country,
+		})
+	}
+
+	posterPath := ""
+	if kpFilm.PosterUrlPreview != "" {
+		posterPath = kpFilm.PosterUrlPreview
+	} else if kpFilm.PosterUrl != "" {
+		posterPath = kpFilm.PosterUrl
+	}
+
+	backdropPath := ""
+	if kpFilm.CoverUrl != "" {
+		backdropPath = kpFilm.CoverUrl
+	}
+
+	overview := kpFilm.Description
+	if overview == "" {
+		overview = kpFilm.ShortDescription
+	}
+
+	title := kpFilm.NameRu
+	if title == "" {
+		title = kpFilm.NameEn
+	}
+	if title == "" {
+		title = kpFilm.NameOriginal
+	}
+
+	originalTitle := kpFilm.NameOriginal
+	if originalTitle == "" {
+		originalTitle = kpFilm.NameEn
+	}
+
+	return &models.Movie{
+		ID:              kpFilm.KinopoiskId,
+		Title:           title,
+		OriginalTitle:   originalTitle,
+		Overview:        overview,
+		PosterPath:      posterPath,
+		BackdropPath:    backdropPath,
+		ReleaseDate:     releaseDate,
+		VoteAverage:     kpFilm.RatingKinopoisk,
+		VoteCount:       kpFilm.RatingKinopoiskVoteCount,
+		Popularity:      float64(kpFilm.RatingKinopoisk * 100),
+		Adult:           false,
+		OriginalLanguage: detectLanguage(kpFilm),
+		Runtime:         kpFilm.FilmLength,
+		Genres:          genres,
+		Tagline:         kpFilm.Slogan,
+		ProductionCountries: countries,
+		IMDbID:          kpFilm.ImdbId,
+		KinopoiskID:     kpFilm.KinopoiskId,
+	}
+}
+
+func MapKPFilmToTVShow(kpFilm *KPFilm) *models.TVShow {
+	if kpFilm == nil {
+		return nil
+	}
+
+	firstAirDate := ""
+	if kpFilm.StartYear > 0 {
+		firstAirDate = fmt.Sprintf("%d-01-01", kpFilm.StartYear)
+	}
+
+	lastAirDate := ""
+	if kpFilm.EndYear > 0 {
+		lastAirDate = fmt.Sprintf("%d-01-01", kpFilm.EndYear)
+	}
+
+	genres := make([]models.Genre, 0)
+	for _, g := range kpFilm.Genres {
+		genres = append(genres, models.Genre{
+			ID:   0,
+			Name: g.Genre,
+		})
+	}
+
+	posterPath := ""
+	if kpFilm.PosterUrlPreview != "" {
+		posterPath = kpFilm.PosterUrlPreview
+	} else if kpFilm.PosterUrl != "" {
+		posterPath = kpFilm.PosterUrl
+	}
+
+	backdropPath := ""
+	if kpFilm.CoverUrl != "" {
+		backdropPath = kpFilm.CoverUrl
+	}
+
+	overview := kpFilm.Description
+	if overview == "" {
+		overview = kpFilm.ShortDescription
+	}
+
+	name := kpFilm.NameRu
+	if name == "" {
+		name = kpFilm.NameEn
+	}
+	if name == "" {
+		name = kpFilm.NameOriginal
+	}
+
+	originalName := kpFilm.NameOriginal
+	if originalName == "" {
+		originalName = kpFilm.NameEn
+	}
+
+	status := "Ended"
+	if kpFilm.Completed {
+		status = "Ended"
+	} else {
+		status = "Returning Series"
+	}
+
+	return &models.TVShow{
+		ID:              kpFilm.KinopoiskId,
+		Name:            name,
+		OriginalName:    originalName,
+		Overview:        overview,
+		PosterPath:      posterPath,
+		BackdropPath:    backdropPath,
+		FirstAirDate:    firstAirDate,
+		LastAirDate:     lastAirDate,
+		VoteAverage:     kpFilm.RatingKinopoisk,
+		VoteCount:       kpFilm.RatingKinopoiskVoteCount,
+		Popularity:      float64(kpFilm.RatingKinopoisk * 100),
+		OriginalLanguage: detectLanguage(kpFilm),
+		Genres:          genres,
+		Status:          status,
+		InProduction:    !kpFilm.Completed,
+		KinopoiskID:     kpFilm.KinopoiskId,
+	}
+}
+
+// Unified mappers with prefixed IDs
+func MapKPToUnified(kpFilm *KPFilm) *models.UnifiedContent {
+    if kpFilm == nil {
+        return nil
+    }
+
+    releaseDate := FormatKPDate(kpFilm.Year)
+    endDate := (*string)(nil)
+    if kpFilm.EndYear > 0 {
+        v := FormatKPDate(kpFilm.EndYear)
+        endDate = &v
+    }
+
+    genres := make([]models.UnifiedGenre, 0)
+    for _, g := range kpFilm.Genres {
+        genres = append(genres, models.UnifiedGenre{ID: strings.ToLower(g.Genre), Name: g.Genre})
+    }
+
+    poster := kpFilm.PosterUrlPreview
+    if poster == "" {
+        poster = kpFilm.PosterUrl
+    }
+
+    country := ""
+    if len(kpFilm.Countries) > 0 {
+        country = kpFilm.Countries[0].Country
+    }
+
+    title := kpFilm.NameRu
+    if title == "" {
+        title = kpFilm.NameEn
+    }
+    originalTitle := kpFilm.NameOriginal
+    if originalTitle == "" {
+        originalTitle = kpFilm.NameEn
+    }
+
+    var budgetPtr *int64
+    var revenuePtr *int64
+
+    external := models.UnifiedExternalIDs{KP: &kpFilm.KinopoiskId, TMDB: nil, IMDb: kpFilm.ImdbId}
+
+    return &models.UnifiedContent{
+        ID:            strconv.Itoa(kpFilm.KinopoiskId),
+        SourceID:      "kp_" + strconv.Itoa(kpFilm.KinopoiskId),
+        Title:         title,
+        OriginalTitle: originalTitle,
+        Description:   firstNonEmpty(kpFilm.Description, kpFilm.ShortDescription),
+        ReleaseDate:   releaseDate,
+        EndDate:       endDate,
+        Type:          mapKPTypeToUnified(kpFilm),
+        Genres:        genres,
+        Rating:        kpFilm.RatingKinopoisk,
+        PosterURL:     BuildAPIImageProxyURL(poster, "w500"),
+        BackdropURL:   BuildAPIImageProxyURL(kpFilm.CoverUrl, "w1280"),
+        Director:      "",
+        Cast:          []models.UnifiedCastMember{},
+        Duration:      kpFilm.FilmLength,
+        Country:       country,
+        Language:      detectLanguage(kpFilm),
+        Budget:        budgetPtr,
+        Revenue:       revenuePtr,
+        IMDbID:        kpFilm.ImdbId,
+        ExternalIDs:   external,
+    }
+}
+
+func mapKPTypeToUnified(kp *KPFilm) string {
+    if kp.Serial || kp.Type == "TV_SERIES" || kp.Type == "MINI_SERIES" {
+        return "tv"
+    }
+    return "movie"
+}
+
+func firstNonEmpty(values ...string) string {
+    for _, v := range values {
+        if strings.TrimSpace(v) != "" {
+            return v
+        }
+    }
+    return ""
+}
+
+func MapKPSearchToTMDBResponse(kpSearch *KPSearchResponse) *models.TMDBResponse {
+	if kpSearch == nil {
+		return &models.TMDBResponse{
+			Page:         1,
+			Results:      []models.Movie{},
+			TotalPages:   0,
+			TotalResults: 0,
+		}
+	}
+
+	results := make([]models.Movie, 0)
+	for _, film := range kpSearch.Films {
+		movie := mapKPFilmShortToMovie(film)
+		if movie != nil {
+			results = append(results, *movie)
+		}
+	}
+
+	totalPages := kpSearch.PagesCount
+	if totalPages == 0 && len(results) > 0 {
+		totalPages = 1
+	}
+
+	return &models.TMDBResponse{
+		Page:         1,
+		Results:      results,
+		TotalPages:   totalPages,
+		TotalResults: kpSearch.SearchFilmsCountResult,
+	}
+}
+
+func mapKPFilmShortToMovie(film KPFilmShort) *models.Movie {
+	genres := make([]models.Genre, 0)
+	for _, g := range film.Genres {
+		genres = append(genres, models.Genre{
+			ID:   0,
+			Name: g.Genre,
+		})
+	}
+
+	year := 0
+	if film.Year != "" {
+		year, _ = strconv.Atoi(film.Year)
+	}
+
+	releaseDate := ""
+	if year > 0 {
+		releaseDate = fmt.Sprintf("%d-01-01", year)
+	}
+
+	posterPath := film.PosterUrlPreview
+	if posterPath == "" {
+		posterPath = film.PosterUrl
+	}
+
+	title := film.NameRu
+	if title == "" {
+		title = film.NameEn
+	}
+
+	originalTitle := film.NameEn
+	if originalTitle == "" {
+		originalTitle = film.NameRu
+	}
+
+	rating := 0.0
+	if film.Rating != "" {
+		rating, _ = strconv.ParseFloat(film.Rating, 64)
+	}
+
+	return &models.Movie{
+		ID:               film.FilmId,
+		Title:            title,
+		OriginalTitle:    originalTitle,
+		Overview:         film.Description,
+		PosterPath:       posterPath,
+		ReleaseDate:      releaseDate,
+		VoteAverage:      rating,
+		VoteCount:        film.RatingVoteCount,
+		Popularity:       rating * 100,
+		Genres:           genres,
+		KinopoiskID:      film.FilmId,
+	}
+}
+
+func detectLanguage(film *KPFilm) string {
+	if film.NameRu != "" {
+		return "ru"
+	}
+	if film.NameEn != "" {
+		return "en"
+	}
+	return "ru"
+}
+
+func MapKPExternalIDsToTMDB(kpFilm *KPFilm) *models.ExternalIDs {
+	if kpFilm == nil {
+		return &models.ExternalIDs{}
+	}
+
+	return &models.ExternalIDs{
+		ID:          kpFilm.KinopoiskId,
+		IMDbID:      kpFilm.ImdbId,
+		KinopoiskID: kpFilm.KinopoiskId,
+	}
+}
+
+func ShouldUseKinopoisk(language string) bool {
+	if language == "" {
+		return false
+	}
+	lang := strings.ToLower(language)
+	return strings.HasPrefix(lang, "ru")
+}
+
+func NormalizeLanguage(language string) string {
+	if language == "" {
+		return "en-US"
+	}
+	
+	lang := strings.ToLower(language)
+	if strings.HasPrefix(lang, "ru") {
+		return "ru-RU"
+	}
+	
+	return "en-US"
+}
+
+func ConvertKPRatingToTMDB(kpRating float64) float64 {
+	return kpRating
+}
+
+func FormatKPDate(year int) string {
+	if year <= 0 {
+		return time.Now().Format("2006-01-02")
+	}
+	return fmt.Sprintf("%d-01-01", year)
+}
+
+// EnrichKPWithTMDBID обогащает KP контент TMDB ID через IMDB ID
+func EnrichKPWithTMDBID(content *models.UnifiedContent, tmdbService *TMDBService) {
+	if content == nil || content.IMDbID == "" || content.ExternalIDs.TMDB != nil {
+		return
+	}
+	
+	mediaType := "movie"
+	if content.Type == "tv" {
+		mediaType = "tv"
+	}
+	
+	if tmdbID, err := tmdbService.FindTMDBIdByIMDB(content.IMDbID, mediaType, "ru-RU"); err == nil {
+		content.ExternalIDs.TMDB = &tmdbID
+	}
+}
+
+// EnrichKPSearchItemsWithTMDBID обогащает массив поисковых элементов TMDB ID
+func EnrichKPSearchItemsWithTMDBID(items []models.UnifiedSearchItem, tmdbService *TMDBService) {
+	for i := range items {
+		if items[i].ExternalIDs.IMDb == "" || items[i].ExternalIDs.TMDB != nil {
+			continue
+		}
+		
+		mediaType := "movie"
+		if items[i].Type == "tv" {
+			mediaType = "tv"
+		}
+		
+		if tmdbID, err := tmdbService.FindTMDBIdByIMDB(items[i].ExternalIDs.IMDb, mediaType, "ru-RU"); err == nil {
+			items[i].ExternalIDs.TMDB = &tmdbID
+		}
+	}
+}

pkg/services/movie.go

@@ -1,34 +1,88 @@
 package services
 
 import (
+	"fmt"
 	"go.mongodb.org/mongo-driver/mongo"
 
 	"neomovies-api/pkg/models"
 )
 
 type MovieService struct {
-	tmdb *TMDBService
+	tmdb      *TMDBService
+	kpService *KinopoiskService
 }
 
-func NewMovieService(db *mongo.Database, tmdb *TMDBService) *MovieService {
+func NewMovieService(db *mongo.Database, tmdb *TMDBService, kpService *KinopoiskService) *MovieService {
 	return &MovieService{
-		tmdb: tmdb,
+		tmdb:      tmdb,
+		kpService: kpService,
 	}
 }
 
 func (s *MovieService) Search(query string, page int, language, region string, year int) (*models.TMDBResponse, error) {
+	if ShouldUseKinopoisk(language) && s.kpService != nil {
+		kpSearch, err := s.kpService.SearchFilms(query, page)
+		if err == nil {
+			return MapKPSearchToTMDBResponse(kpSearch), nil
+		}
+	}
 	return s.tmdb.SearchMovies(query, page, language, region, year)
 }
 
-func (s *MovieService) GetByID(id int, language string) (*models.Movie, error) {
+func (s *MovieService) GetByID(id int, language string, idType string) (*models.Movie, error) {
-	return s.tmdb.GetMovie(id, language)
+    // Строго уважаем явный id_type, без скрытого fallback на TMDB
+    switch idType {
+    case "kp":
+        if s.kpService == nil {
+            return nil, fmt.Errorf("kinopoisk service not configured")
+        }
+
+        // Сначала пробуем как Kinopoisk ID
+        if kpFilm, err := s.kpService.GetFilmByKinopoiskId(id); err == nil {
+            // Возвращаем KP-модель в TMDB-формате без подмены на TMDB объект
+            return MapKPFilmToTMDBMovie(kpFilm), nil
+        }
+
+        // Возможно пришел TMDB ID — пробуем конвертировать TMDB -> KP
+        if kpId, convErr := TmdbIdToKPId(s.tmdb, s.kpService, id); convErr == nil {
+            if kpFilm, err := s.kpService.GetFilmByKinopoiskId(kpId); err == nil {
+                return MapKPFilmToTMDBMovie(kpFilm), nil
+            }
+        }
+        // Явно указан KP, но ничего не нашли — возвращаем ошибку
+        return nil, fmt.Errorf("film not found in Kinopoisk with id %d", id)
+
+    case "tmdb":
+        return s.tmdb.GetMovie(id, language)
+    }
+
+    // Если id_type не указан — старая логика по языку
+    if ShouldUseKinopoisk(language) && s.kpService != nil {
+        if kpFilm, err := s.kpService.GetFilmByKinopoiskId(id); err == nil {
+            return MapKPFilmToTMDBMovie(kpFilm), nil
+        }
+    }
+
+    return s.tmdb.GetMovie(id, language)
 }
 
 func (s *MovieService) GetPopular(page int, language, region string) (*models.TMDBResponse, error) {
+	if ShouldUseKinopoisk(language) && s.kpService != nil {
+		kpTop, err := s.kpService.GetTopFilms("TOP_100_POPULAR_FILMS", page)
+		if err == nil {
+			return MapKPSearchToTMDBResponse(kpTop), nil
+		}
+	}
 	return s.tmdb.GetPopularMovies(page, language, region)
 }
 
 func (s *MovieService) GetTopRated(page int, language, region string) (*models.TMDBResponse, error) {
+	if ShouldUseKinopoisk(language) && s.kpService != nil {
+		kpTop, err := s.kpService.GetTopFilms("TOP_250_BEST_FILMS", page)
+		if err == nil {
+			return MapKPSearchToTMDBResponse(kpTop), nil
+		}
+	}
 	return s.tmdb.GetTopRatedMovies(page, language, region)
 }
 
@@ -49,5 +103,34 @@ func (s *MovieService) GetSimilar(id, page int, language string) (*models.TMDBRe
 }
 
 func (s *MovieService) GetExternalIDs(id int) (*models.ExternalIDs, error) {
-	return s.tmdb.GetMovieExternalIDs(id)
+	if s.kpService != nil {
+		kpFilm, err := s.kpService.GetFilmByKinopoiskId(id)
+		if err == nil && kpFilm != nil {
+			externalIDs := MapKPExternalIDsToTMDB(kpFilm)
+			externalIDs.ID = id
+			
+			// Пытаемся получить TMDB ID через IMDB ID
+			if kpFilm.ImdbId != "" && s.tmdb != nil {
+				if tmdbID, tmdbErr := s.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "movie", "ru-RU"); tmdbErr == nil {
+					externalIDs.TMDBID = tmdbID
+				}
+			}
+			
+			return externalIDs, nil
+		}
+	}
+	
+	tmdbIDs, err := s.tmdb.GetMovieExternalIDs(id)
+	if err != nil {
+		return nil, err
+	}
+	
+	if s.kpService != nil && tmdbIDs.IMDbID != "" {
+		kpFilm, err := s.kpService.GetFilmByImdbId(tmdbIDs.IMDbID)
+		if err == nil && kpFilm != nil {
+			tmdbIDs.KinopoiskID = kpFilm.KinopoiskId
+		}
+	}
+	
+	return tmdbIDs, nil
 }

pkg/services/tmdb.go

@@ -1,13 +1,13 @@
 package services
 
 import (
-	"encoding/json"
+    "encoding/json"
-	"fmt"
+    "fmt"
-	"net/http"
+    "net/http"
-	"net/url"
+    "net/url"
-	"strconv"
+    "strconv"
 
-	"neomovies-api/pkg/models"
+    "neomovies-api/pkg/models"
 )
 
 type TMDBService struct {
@@ -179,6 +179,48 @@ func (s *TMDBService) GetTVShow(id int, language string) (*models.TVShow, error)
 	return &tvShow, err
 }
 
+// FindTMDBIdByIMDB finds TMDB IDs by external IMDb ID using /find/{external_id}
+// media: "movie" | "tv" | "" (auto)
+func (s *TMDBService) FindTMDBIdByIMDB(imdbID string, media string, language string) (int, error) {
+    if imdbID == "" {
+        return 0, fmt.Errorf("imdb id is empty")
+    }
+    if language == "" {
+        language = "ru-RU"
+    }
+    params := url.Values{}
+    params.Set("external_source", "imdb_id")
+    params.Set("language", language)
+    endpoint := fmt.Sprintf("%s/find/%s?%s", s.baseURL, url.PathEscape(imdbID), params.Encode())
+
+    var resp struct {
+        MovieResults []struct{ ID int `json:"id"` } `json:"movie_results"`
+        TVResults    []struct{ ID int `json:"id"` } `json:"tv_results"`
+    }
+    if err := s.makeRequest(endpoint, &resp); err != nil {
+        return 0, err
+    }
+
+    switch media {
+    case "movie":
+        if len(resp.MovieResults) > 0 {
+            return resp.MovieResults[0].ID, nil
+        }
+    case "tv":
+        if len(resp.TVResults) > 0 {
+            return resp.TVResults[0].ID, nil
+        }
+    default:
+        if len(resp.MovieResults) > 0 {
+            return resp.MovieResults[0].ID, nil
+        }
+        if len(resp.TVResults) > 0 {
+            return resp.TVResults[0].ID, nil
+        }
+    }
+    return 0, fmt.Errorf("tmdb id not found for imdb %s", imdbID)
+}
+
 func (s *TMDBService) GetGenres(mediaType string, language string) (*models.GenresResponse, error) {
 	params := url.Values{}
 

pkg/services/tv.go

@@ -1,20 +1,23 @@
 package services
 
 import (
+	"fmt"
 	"go.mongodb.org/mongo-driver/mongo"
 
 	"neomovies-api/pkg/models"
 )
 
 type TVService struct {
-	db   *mongo.Database
+	db        *mongo.Database
-	tmdb *TMDBService
+	tmdb      *TMDBService
+	kpService *KinopoiskService
 }
 
-func NewTVService(db *mongo.Database, tmdb *TMDBService) *TVService {
+func NewTVService(db *mongo.Database, tmdb *TMDBService, kpService *KinopoiskService) *TVService {
 	return &TVService{
-		db:   db,
+		db:        db,
-		tmdb: tmdb,
+		tmdb:      tmdb,
+		kpService: kpService,
 	}
 }
 
@@ -22,8 +25,55 @@ func (s *TVService) Search(query string, page int, language string, year int) (*
 	return s.tmdb.SearchTVShows(query, page, language, year)
 }
 
-func (s *TVService) GetByID(id int, language string) (*models.TVShow, error) {
+func (s *TVService) GetByID(id int, language string, idType string) (*models.TVShow, error) {
-	return s.tmdb.GetTVShow(id, language)
+    // Строго уважаем явный id_type, без скрытого fallback на TMDB
+    switch idType {
+    case "kp":
+        if s.kpService == nil {
+            return nil, fmt.Errorf("kinopoisk service not configured")
+        }
+
+        // Сначала пробуем как Kinopoisk ID
+        if kpFilm, err := s.kpService.GetFilmByKinopoiskId(id); err == nil && kpFilm != nil {
+            // Попробуем обогатить TMDB сериал через IMDb -> TMDB find
+            if kpFilm.ImdbId != "" {
+                if tmdbID, fErr := s.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "tv", NormalizeLanguage(language)); fErr == nil {
+                    if tmdbTV, mErr := s.tmdb.GetTVShow(tmdbID, NormalizeLanguage(language)); mErr == nil {
+                        return tmdbTV, nil
+                    }
+                }
+            }
+            return MapKPFilmToTVShow(kpFilm), nil
+        }
+
+        // Возможно пришел TMDB ID — пробуем конвертировать TMDB -> KP
+        if kpId, convErr := TmdbIdToKPId(s.tmdb, s.kpService, id); convErr == nil {
+            if kpFilm, err := s.kpService.GetFilmByKinopoiskId(kpId); err == nil && kpFilm != nil {
+                if kpFilm.ImdbId != "" {
+                    if tmdbID, fErr := s.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "tv", NormalizeLanguage(language)); fErr == nil {
+                        if tmdbTV, mErr := s.tmdb.GetTVShow(tmdbID, NormalizeLanguage(language)); mErr == nil {
+                            return tmdbTV, nil
+                        }
+                    }
+                }
+                return MapKPFilmToTVShow(kpFilm), nil
+            }
+        }
+        // Явно указан KP, но ничего не нашли — возвращаем ошибку
+        return nil, fmt.Errorf("TV show not found in Kinopoisk with id %d", id)
+
+    case "tmdb":
+        return s.tmdb.GetTVShow(id, language)
+    }
+
+    // Если id_type не указан — старая логика по языку
+    if ShouldUseKinopoisk(language) && s.kpService != nil {
+        if kpFilm, err := s.kpService.GetFilmByKinopoiskId(id); err == nil && kpFilm != nil {
+            return MapKPFilmToTVShow(kpFilm), nil
+        }
+    }
+
+    return s.tmdb.GetTVShow(id, language)
 }
 
 func (s *TVService) GetPopular(page int, language string) (*models.TMDBTVResponse, error) {
@@ -51,5 +101,34 @@ func (s *TVService) GetSimilar(id, page int, language string) (*models.TMDBTVRes
 }
 
 func (s *TVService) GetExternalIDs(id int) (*models.ExternalIDs, error) {
-	return s.tmdb.GetTVExternalIDs(id)
+	if s.kpService != nil {
+		kpFilm, err := s.kpService.GetFilmByKinopoiskId(id)
+		if err == nil && kpFilm != nil {
+			externalIDs := MapKPExternalIDsToTMDB(kpFilm)
+			externalIDs.ID = id
+			
+			// Пытаемся получить TMDB ID через IMDB ID
+			if kpFilm.ImdbId != "" && s.tmdb != nil {
+				if tmdbID, tmdbErr := s.tmdb.FindTMDBIdByIMDB(kpFilm.ImdbId, "tv", "ru-RU"); tmdbErr == nil {
+					externalIDs.TMDBID = tmdbID
+				}
+			}
+			
+			return externalIDs, nil
+		}
+	}
+	
+	tmdbIDs, err := s.tmdb.GetTVExternalIDs(id)
+	if err != nil {
+		return nil, err
+	}
+	
+	if s.kpService != nil && tmdbIDs.IMDbID != "" {
+		kpFilm, err := s.kpService.GetFilmByImdbId(tmdbIDs.IMDbID)
+		if err == nil && kpFilm != nil {
+			tmdbIDs.KinopoiskID = kpFilm.KinopoiskId
+		}
+	}
+	
+	return tmdbIDs, nil
 }

pkg/services/unified_mapper.go

@@ -0,0 +1,275 @@
+package services
+
+import (
+    "fmt"
+    "net/url"
+    "strconv"
+    "strings"
+
+    "neomovies-api/pkg/models"
+)
+
+const tmdbImageBase = "https://image.tmdb.org/t/p"
+
+// BuildAPIImageProxyURL строит относительный URL до нашего прокси-эндпоинта изображений.
+// Если передан абсолютный URL (KP и пр.) — он кодируется и передаётся как path параметр.
+// Если передан относительный TMDB-путь, он используется как есть (без ведущего '/').
+func BuildAPIImageProxyURL(pathOrURL string, size string) string {
+    if strings.TrimSpace(pathOrURL) == "" {
+        return ""
+    }
+    if size == "" {
+        size = "w500"
+    }
+    // Абсолютные ссылки (Kinopoisk и пр.) — кодируем целиком
+    if strings.HasPrefix(pathOrURL, "http://") || strings.HasPrefix(pathOrURL, "https://") {
+        return fmt.Sprintf("/api/v1/images/%s/%s", size, url.QueryEscape(pathOrURL))
+    }
+    // TMDB относительный путь
+    clean := pathOrURL
+    if strings.HasPrefix(clean, "/") {
+        clean = clean[1:]
+    }
+    return fmt.Sprintf("/api/v1/images/%s/%s", size, clean)
+}
+
+func MapTMDBToUnifiedMovie(movie *models.Movie, external *models.ExternalIDs) *models.UnifiedContent {
+    if movie == nil {
+        return nil
+    }
+
+    genres := make([]models.UnifiedGenre, 0, len(movie.Genres))
+    for _, g := range movie.Genres {
+        name := strings.TrimSpace(g.Name)
+        id := strings.ToLower(strings.ReplaceAll(name, " ", "-"))
+        if id == "" {
+            id = strconv.Itoa(g.ID)
+        }
+        genres = append(genres, models.UnifiedGenre{ID: id, Name: name})
+    }
+
+    var imdb string
+    if external != nil {
+        imdb = external.IMDbID
+    }
+
+    var budgetPtr *int64
+    if movie.Budget > 0 {
+        v := movie.Budget
+        budgetPtr = &v
+    }
+    var revenuePtr *int64
+    if movie.Revenue > 0 {
+        v := movie.Revenue
+        revenuePtr = &v
+    }
+
+    ext := models.UnifiedExternalIDs{
+        KP:   nil,
+        TMDB: &movie.ID,
+        IMDb: imdb,
+    }
+
+    return &models.UnifiedContent{
+        ID:            strconv.Itoa(movie.ID),
+        SourceID:      "tmdb_" + strconv.Itoa(movie.ID),
+        Title:         movie.Title,
+        OriginalTitle: movie.OriginalTitle,
+        Description:   movie.Overview,
+        ReleaseDate:   movie.ReleaseDate,
+        EndDate:       nil,
+        Type:          "movie",
+        Genres:        genres,
+        Rating:        movie.VoteAverage,
+        PosterURL:     BuildAPIImageProxyURL(movie.PosterPath, "w500"),
+        BackdropURL:   BuildAPIImageProxyURL(movie.BackdropPath, "w1280"),
+        Director:      "",
+        Cast:          []models.UnifiedCastMember{},
+        Duration:      movie.Runtime,
+        Country:       firstCountry(movie.ProductionCountries),
+        Language:      movie.OriginalLanguage,
+        Budget:        budgetPtr,
+        Revenue:       revenuePtr,
+        IMDbID:        imdb,
+        ExternalIDs:   ext,
+    }
+}
+
+func MapTMDBTVToUnified(tv *models.TVShow, external *models.ExternalIDs) *models.UnifiedContent {
+    if tv == nil {
+        return nil
+    }
+
+    genres := make([]models.UnifiedGenre, 0, len(tv.Genres))
+    for _, g := range tv.Genres {
+        name := strings.TrimSpace(g.Name)
+        id := strings.ToLower(strings.ReplaceAll(name, " ", "-"))
+        if id == "" {
+            id = strconv.Itoa(g.ID)
+        }
+        genres = append(genres, models.UnifiedGenre{ID: id, Name: name})
+    }
+
+    var imdb string
+    if external != nil {
+        imdb = external.IMDbID
+    }
+
+    endDate := (*string)(nil)
+    if strings.TrimSpace(tv.LastAirDate) != "" {
+        v := tv.LastAirDate
+        endDate = &v
+    }
+
+    ext := models.UnifiedExternalIDs{
+        KP:   nil,
+        TMDB: &tv.ID,
+        IMDb: imdb,
+    }
+
+    duration := 0
+    if len(tv.EpisodeRunTime) > 0 {
+        duration = tv.EpisodeRunTime[0]
+    }
+
+    unified := &models.UnifiedContent{
+        ID:            strconv.Itoa(tv.ID),
+        SourceID:      "tmdb_" + strconv.Itoa(tv.ID),
+        Title:         tv.Name,
+        OriginalTitle: tv.OriginalName,
+        Description:   tv.Overview,
+        ReleaseDate:   tv.FirstAirDate,
+        EndDate:       endDate,
+        Type:          "tv",
+        Genres:        genres,
+        Rating:        tv.VoteAverage,
+        PosterURL:     BuildAPIImageProxyURL(tv.PosterPath, "w500"),
+        BackdropURL:   BuildAPIImageProxyURL(tv.BackdropPath, "w1280"),
+        Director:      "",
+        Cast:          []models.UnifiedCastMember{},
+        Duration:      duration,
+        Country:       firstCountry(tv.ProductionCountries),
+        Language:      tv.OriginalLanguage,
+        Budget:        nil,
+        Revenue:       nil,
+        IMDbID:        imdb,
+        ExternalIDs:   ext,
+    }
+
+    // Map seasons basic info
+    if len(tv.Seasons) > 0 {
+        unified.Seasons = make([]models.UnifiedSeason, 0, len(tv.Seasons))
+        for _, s := range tv.Seasons {
+            unified.Seasons = append(unified.Seasons, models.UnifiedSeason{
+                ID:           strconv.Itoa(s.ID),
+                SourceID:     "tmdb_" + strconv.Itoa(s.ID),
+                Name:         s.Name,
+                SeasonNumber: s.SeasonNumber,
+                EpisodeCount: s.EpisodeCount,
+                ReleaseDate:  s.AirDate,
+                PosterURL:    BuildAPIImageProxyURL(s.PosterPath, "w500"),
+            })
+        }
+    }
+
+    return unified
+}
+
+func MapTMDBMultiToUnifiedItems(m *models.MultiSearchResponse) []models.UnifiedSearchItem {
+    if m == nil {
+        return []models.UnifiedSearchItem{}
+    }
+    items := make([]models.UnifiedSearchItem, 0, len(m.Results))
+    for _, r := range m.Results {
+        if r.MediaType != "movie" && r.MediaType != "tv" {
+            continue
+        }
+        title := r.Title
+        if r.MediaType == "tv" {
+            title = r.Name
+        }
+        release := r.ReleaseDate
+        if r.MediaType == "tv" {
+            release = r.FirstAirDate
+        }
+        poster := BuildAPIImageProxyURL(r.PosterPath, "w500")
+        tmdbId := r.ID
+        items = append(items, models.UnifiedSearchItem{
+            ID:          strconv.Itoa(tmdbId),
+            SourceID:    "tmdb_" + strconv.Itoa(tmdbId),
+            Title:       title,
+            Type:        map[string]string{"movie":"movie","tv":"tv"}[r.MediaType],
+            ReleaseDate: release,
+            PosterURL:   poster,
+            Rating:      r.VoteAverage,
+            Description: r.Overview,
+            ExternalIDs: models.UnifiedExternalIDs{KP: nil, TMDB: &tmdbId, IMDb: ""},
+        })
+    }
+    return items
+}
+
+func MapKPSearchToUnifiedItems(kps *KPSearchResponse) []models.UnifiedSearchItem {
+    if kps == nil {
+        return []models.UnifiedSearchItem{}
+    }
+    items := make([]models.UnifiedSearchItem, 0, len(kps.Films))
+    for _, f := range kps.Films {
+        title := f.NameRu
+        if strings.TrimSpace(title) == "" {
+            title = f.NameEn
+        }
+        poster := f.PosterUrlPreview
+        if poster == "" {
+            poster = f.PosterUrl
+        }
+        poster = BuildAPIImageProxyURL(poster, "w500")
+        rating := 0.0
+        if strings.TrimSpace(f.Rating) != "" {
+            if v, err := strconv.ParseFloat(f.Rating, 64); err == nil {
+                rating = v
+            }
+        }
+        kpId := f.FilmId
+        items = append(items, models.UnifiedSearchItem{
+            ID:          strconv.Itoa(kpId),
+            SourceID:    "kp_" + strconv.Itoa(kpId),
+            Title:       title,
+            Type:        mapKPTypeToUnifiedShort(f.Type),
+            OriginalType: strings.ToUpper(strings.TrimSpace(f.Type)),
+            ReleaseDate: yearToDate(f.Year),
+            PosterURL:   poster,
+            Rating:      rating,
+            Description: f.Description,
+            ExternalIDs: models.UnifiedExternalIDs{KP: &kpId, TMDB: nil, IMDb: ""},
+        })
+    }
+    return items
+}
+
+func mapKPTypeToUnifiedShort(t string) string {
+    switch strings.ToUpper(strings.TrimSpace(t)) {
+    case "TV_SERIES", "MINI_SERIES":
+        return "tv"
+    default:
+        return "movie"
+    }
+}
+
+func yearToDate(y string) string {
+    y = strings.TrimSpace(y)
+    if y == "" {
+        return ""
+    }
+    return y + "-01-01"
+}
+
+func firstCountry(countries []models.ProductionCountry) string {
+    if len(countries) == 0 {
+        return ""
+    }
+    if strings.TrimSpace(countries[0].Name) != "" {
+        return countries[0].Name
+    }
+    return countries[0].ISO31661
+}