fix: Remove TMDB fallback and add ID conversion for strict id_type handling

ПРОБЛЕМА:
- При id_type='kp' код делал fallback на TMDB если фильм не найден
- Если передан TMDB ID с id_type='kp', возвращались данные из TMDB
- Нарушалась явная логика выбора источника

РЕШЕНИЕ:
1. Убран автоматический fallback на TMDB при id_type='kp'
2. Добавлена конвертация ID:
   - Если id_type='kp' и фильм не найден напрямую
   - Пробуем конвертировать TMDB ID → KP ID через TmdbIdToKPId
   - Запрашиваем данные по сконвертированному KP ID
3. Если конвертация не удалась → возвращаем ошибку

ЛОГИКА:
- id_type='kp' + ID=550 (TMDB):
  1. Поиск KP фильма с id=550 → не найдено
  2. Конвертация 550 (TMDB) → получаем KP ID (например 326)
  3. Поиск KP фильма с id=326 → успех
  4. Возврат данных из Kinopoisk ✅

- id_type='kp' + несуществующий ID:
  1. Поиск KP фильма → не найдено
  2. Конвертация → не удалась
  3. Возврат ошибки (НЕ fallback на TMDB) ✅

ИЗМЕНЕНИЯ:
- pkg/services/movie.go: добавлена конвертация и удален fallback
- pkg/services/tv.go: добавлена конвертация и удален fallback
- Добавлен import fmt для форматирования ошибок

РЕЗУЛЬТАТ:
✅ Строгое соблюдение id_type параметра
✅ Умная конвертация между TMDB и KP ID
✅ Нет неожиданного fallback на другой источник

.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_here
-PORT=3000
-BASE_URL=http://localhost:3000
-NODE_ENV=development
 
-# Email (Gmail)
+KPAPI_KEY=920aaf6a-9f64-46f7-bda7-209fb1069440
-GMAIL_USER=
+KPAPI_BASE_URL=https://kinopoiskapiunofficial.tech/api
-GMAIL_APP_PASSWORD=
 
-# Players
+HDVB_TOKEN=b9ae5f8c4832244060916af4aa9d1939
-LUMEX_URL=
+
-ALLOHA_TOKEN=
+VIBIX_HOST=https://vibix.org
+VIBIX_TOKEN=18745|NzecUXT4gikPUtFkSEFlDLPmr9kWnQACTo1N0Ixq9240bcf1
+
+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_here
-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

README.md

@@ -4,13 +4,14 @@ REST API для поиска и получения информации о фи
 
 ## Особенности
 
-- Поиск фильмов
+- Интеграция с Kinopoisk API для русского контента
+- Автоматическое переключение между TMDB и Kinopoisk
+- Поиск фильмов и сериалов
 - Информация о фильмах
-- Популярные фильмы
+- Популярные, топ-рейтинговые, предстоящие фильмы
-- Топ рейтинговые фильмы
+- Поддержка русских плееров (Alloha, Lumex, Vibix, HDVB)
-- Предстоящие фильмы
 - Swagger документация
-- Поддержка русского языка
+- Полная поддержка русского языка
 
 ## 🛠 Быстрый старт
 
@@ -50,32 +51,39 @@ 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=920aaf6a-9f64-46f7-bda7-209fb1069440
+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=18745|NzecUXT4gikPUtFkSEFlDLPmr9kWnQACTo1N0Ixq9240bcf1
+HDVB_TOKEN=b9ae5f8c4832244060916af4aa9d1939
 
 # Торренты (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
 ```
 
@@ -120,10 +128,14 @@ GET  /api/v1/tv/{id}                         # Детали сериала
 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 +255,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,7 @@ 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)
 	categoriesHandler := handlersPkg.NewCategoriesHandler(tmdbService)
 	playersHandler := handlersPkg.NewPlayersHandler(globalCfg)
 	torrentsHandler := handlersPkg.NewTorrentsHandler(torrentService, tmdbService)
@@ -94,9 +95,10 @@ 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/{imdb_id}", playersHandler.GetVibixPlayer).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")

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,7 @@ func main() {
 	tvHandler := appHandlers.NewTVHandler(tvService)
 	favoritesHandler := appHandlers.NewFavoritesHandler(favoritesService, cfg)
 	docsHandler := appHandlers.NewDocsHandler()
-	searchHandler := appHandlers.NewSearchHandler(tmdbService)
+	searchHandler := appHandlers.NewSearchHandler(tmdbService, kpService)
 	categoriesHandler := appHandlers.NewCategoriesHandler(tmdbService)
 	playersHandler := appHandlers.NewPlayersHandler(cfg)
 	torrentsHandler := appHandlers.NewTorrentsHandler(torrentService, tmdbService)
@@ -75,12 +76,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")

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)
 }
 

pkg/handlers/movie.go

@@ -55,8 +55,9 @@ func (h *MovieHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 	}
 
 	language := GetLanguage(r)
+	idType := r.URL.Query().Get("id_type") // kp or tmdb
 
-	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

pkg/handlers/players.go

@@ -30,16 +30,22 @@ 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 != "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.AllohaToken == "" {
 		log.Printf("Error: ALLOHA_TOKEN is missing")
@@ -47,7 +53,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)
 
@@ -104,7 +110,7 @@ func (h *PlayersHandler) GetAllohaPlayer(w http.ResponseWriter, r *http.Request)
 
 	// Используем iframe URL из API
 	iframeCode := allohaResponse.Data.Iframe
-	
+
 	// Если это не HTML код, а просто URL
 	var playerURL string
 	if !strings.Contains(iframeCode, "<") {
@@ -129,23 +135,29 @@ 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 != "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.LumexURL == "" {
 		log.Printf("Error: LUMEX_URL is missing")
@@ -153,9 +165,15 @@ func (h *PlayersHandler) GetLumexPlayer(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	// Lumex использует только IMDb ID без season/episode
+	var paramName string
-	playerURL := fmt.Sprintf("%s?imdb_id=%s", h.config.LumexURL, imdbID)
+	if idType == "kp" {
-	log.Printf("🔗 Lumex URL: %s", playerURL)
+		paramName = "kinopoisk_id"
+	} else {
+		paramName = "imdb_id"
+	}
+
+	playerURL := fmt.Sprintf("%s?%s=%s", h.config.LumexURL, paramName, 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)
@@ -163,23 +181,29 @@ func (h *PlayersHandler) GetLumexPlayer(w http.ResponseWriter, r *http.Request)
 	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)
-	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 != "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")
@@ -192,7 +216,14 @@ func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request)
 		vibixHost = "https://vibix.org"
 	}
 
-	apiURL := fmt.Sprintf("%s/api/v1/publisher/videos/imdb/%s", vibixHost, imdbID)
+	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)
@@ -203,7 +234,7 @@ func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request)
 	}
 
 	req.Header.Set("Accept", "application/json")
-	req.Header.Set("Authorization", "Bearer "+h.config.VibixToken)
+	req.Header.Set("Authorization", h.config.VibixToken)
 	req.Header.Set("X-CSRF-TOKEN", "")
 
 	client := &http.Client{Timeout: 8 * time.Second}
@@ -259,7 +290,7 @@ func (h *PlayersHandler) GetVibixPlayer(w http.ResponseWriter, r *http.Request)
 	w.Header().Set("Content-Type", "text/html")
 	w.Write([]byte(htmlDoc))
 
-	log.Printf("Successfully served Vibix player for imdb_id: %s", imdbID)
+	log.Printf("Successfully served Vibix player for %s: %s", idType, id)
 }
 
 // GetRgShowsPlayer handles RgShows streaming requests
@@ -463,16 +494,16 @@ func (h *PlayersHandler) GetStreamAPI(w http.ResponseWriter, r *http.Request) {
 // 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)
@@ -488,72 +519,153 @@ func (h *PlayersHandler) GetVidsrcPlayer(w http.ResponseWriter, r *http.Request)
 		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)
 }
 

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,
 	}
 }
 
@@ -28,6 +30,42 @@ func (h *SearchHandler) MultiSearch(w http.ResponseWriter, r *http.Request) {
 	page := getIntQuery(r, "page", 1)
 	language := GetLanguage(r)
 
+	if services.ShouldUseKinopoisk(language) && h.kpService != nil {
+		kpSearch, err := h.kpService.SearchFilms(query, page)
+		if err == nil {
+			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
+		}
+	}
+
 	results, err := h.tmdbService.SearchMulti(query, page, language)
 	if err != nil {
 		http.Error(w, err.Error(), http.StatusInternalServerError)

pkg/handlers/tv.go

@@ -54,8 +54,9 @@ func (h *TVHandler) GetByID(w http.ResponseWriter, r *http.Request) {
 	}
 
 	language := GetLanguage(r)
+	idType := r.URL.Query().Get("id_type") // kp or tmdb
 
-	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

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,7 @@ type GenresResponse struct {
 type ExternalIDs struct {
 	ID          int    `json:"id"`
 	IMDbID      string `json:"imdb_id"`
+	KinopoiskID int    `json:"kinopoisk_id,omitempty"`
 	TVDBID      int    `json:"tvdb_id,omitempty"`
 	WikidataID  string `json:"wikidata_id"`
 	FacebookID  string `json:"facebook_id"`

pkg/services/kinopoisk.go

@@ -0,0 +1,261 @@
+package services
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"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, 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, 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,307 @@
+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,
+	}
+}
+
+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)
+}

pkg/services/movie.go

@@ -1,34 +1,89 @@
 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) {
+	// Если указан id_type, используем его; иначе определяем по языку
+	useKP := false
+	if idType == "kp" {
+		useKP = true
+	} else if idType == "tmdb" {
+		useKP = false
+	} else {
+		// Если id_type не указан, используем старую логику по языку
+		useKP = ShouldUseKinopoisk(language)
+	}
+	
+	if useKP && s.kpService != nil {
+		// Сначала пробуем напрямую по KP ID
+		kpFilm, err := s.kpService.GetFilmByKinopoiskId(id)
+		if err == nil {
+			return MapKPFilmToTMDBMovie(kpFilm), nil
+		}
+		
+		// Если не найдено и явно указан id_type=kp, возможно это TMDB ID
+		// Пробуем конвертировать TMDB -> KP
+		if idType == "kp" {
+			kpId, convErr := TmdbIdToKPId(s.tmdb, s.kpService, id)
+			if convErr == nil {
+				kpFilm, err := s.kpService.GetFilmByKinopoiskId(kpId)
+				if err == nil {
+					return MapKPFilmToTMDBMovie(kpFilm), nil
+				}
+			}
+			// Если конвертация не удалась, возвращаем ошибку вместо fallback
+			return nil, fmt.Errorf("film not found in Kinopoisk with id %d", id)
+		}
+	}
+	
+	// Для TMDB или если KP не указан
 	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 +104,26 @@ 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
+			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/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,7 +25,41 @@ 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) {
+	// Если указан id_type, используем его; иначе определяем по языку
+	useKP := false
+	if idType == "kp" {
+		useKP = true
+	} else if idType == "tmdb" {
+		useKP = false
+	} else {
+		// Если id_type не указан, используем старую логику по языку
+		useKP = ShouldUseKinopoisk(language)
+	}
+	
+	if useKP && s.kpService != nil {
+		// Сначала пробуем напрямую по KP ID
+		kpFilm, err := s.kpService.GetFilmByKinopoiskId(id)
+		if err == nil && kpFilm != nil {
+			return MapKPFilmToTVShow(kpFilm), nil
+		}
+		
+		// Если не найдено и явно указан id_type=kp, возможно это TMDB ID
+		// Пробуем конвертировать TMDB -> KP
+		if idType == "kp" {
+			kpId, convErr := TmdbIdToKPId(s.tmdb, s.kpService, id)
+			if convErr == nil {
+				kpFilm, err := s.kpService.GetFilmByKinopoiskId(kpId)
+				if err == nil && kpFilm != nil {
+					return MapKPFilmToTVShow(kpFilm), nil
+				}
+			}
+			// Если конвертация не удалась, возвращаем ошибку вместо fallback
+			return nil, fmt.Errorf("TV show not found in Kinopoisk with id %d", id)
+		}
+	}
+	
+	// Для TMDB или если KP не указан
 	return s.tmdb.GetTVShow(id, language)
 }