Rewrite api to Go

pkg/handlers/auth.go

@@ -0,0 +1,159 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"go.mongodb.org/mongo-driver/bson"
+
+	"neomovies-api/pkg/middleware"
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type AuthHandler struct {
+	authService *services.AuthService
+}
+
+func NewAuthHandler(authService *services.AuthService) *AuthHandler {
+	return &AuthHandler{
+		authService: authService,
+	}
+}
+
+func (h *AuthHandler) Register(w http.ResponseWriter, r *http.Request) {
+	var req models.RegisterRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	response, err := h.authService.Register(req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusConflict)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusCreated)
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+		Message: "User registered successfully",
+	})
+}
+
+func (h *AuthHandler) Login(w http.ResponseWriter, r *http.Request) {
+	var req models.LoginRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	response, err := h.authService.Login(req)
+	if err != nil {
+		// Определяем правильный статус код в зависимости от ошибки
+		statusCode := http.StatusBadRequest
+		if err.Error() == "Account not activated. Please verify your email." {
+			statusCode = http.StatusForbidden // 403 для неверифицированного email
+		}
+		http.Error(w, err.Error(), statusCode)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+		Message: "Login successful",
+	})
+}
+
+func (h *AuthHandler) GetProfile(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	user, err := h.authService.GetUserByID(userID)
+	if err != nil {
+		http.Error(w, "User not found", http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    user,
+	})
+}
+
+func (h *AuthHandler) UpdateProfile(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	var updates map[string]interface{}
+	if err := json.NewDecoder(r.Body).Decode(&updates); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	// Удаляем поля, которые нельзя обновлять через этот эндпоинт
+	delete(updates, "password")
+	delete(updates, "email")
+	delete(updates, "_id")
+	delete(updates, "created_at")
+
+	user, err := h.authService.UpdateUser(userID, bson.M(updates))
+	if err != nil {
+		http.Error(w, "Failed to update user", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    user,
+		Message: "Profile updated successfully",
+	})
+}
+
+// Верификация email
+func (h *AuthHandler) VerifyEmail(w http.ResponseWriter, r *http.Request) {
+	var req models.VerifyEmailRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	response, err := h.authService.VerifyEmail(req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}
+
+// Повторная отправка кода верификации
+func (h *AuthHandler) ResendVerificationCode(w http.ResponseWriter, r *http.Request) {
+	var req models.ResendCodeRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	response, err := h.authService.ResendVerificationCode(req)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}

pkg/handlers/categories.go

@@ -0,0 +1,96 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"github.com/gorilla/mux"
+
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type CategoriesHandler struct {
+	tmdbService *services.TMDBService
+}
+
+func NewCategoriesHandler(tmdbService *services.TMDBService) *CategoriesHandler {
+	return &CategoriesHandler{
+		tmdbService: tmdbService,
+	}
+}
+
+type Category struct {
+	ID   int    `json:"id"`
+	Name string `json:"name"`
+	Slug string `json:"slug"`
+}
+
+func (h *CategoriesHandler) GetCategories(w http.ResponseWriter, r *http.Request) {
+	// Получаем все жанры
+	genresResponse, err := h.tmdbService.GetAllGenres()
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Преобразуем жанры в категории
+	var categories []Category
+	for _, genre := range genresResponse.Genres {
+		slug := generateSlug(genre.Name)
+		categories = append(categories, Category{
+			ID:   genre.ID,
+			Name: genre.Name,
+			Slug: slug,
+		})
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    categories,
+	})
+}
+
+func (h *CategoriesHandler) GetMoviesByCategory(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	categoryID, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid category ID", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	if language == "" {
+		language = "ru-RU"
+	}
+
+	// Используем discover API для получения фильмов по жанру
+	movies, err := h.tmdbService.DiscoverMoviesByGenre(categoryID, 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:    movies,
+	})
+}
+
+func generateSlug(name string) string {
+	// Простая функция для создания slug из названия
+	// В реальном проекте стоит использовать более сложную логику
+	result := ""
+	for _, char := range name {
+		if (char >= 'a' && char <= 'z') || (char >= 'A' && char <= 'Z') || (char >= '0' && char <= '9') {
+			result += string(char)
+		} else if char == ' ' {
+			result += "-"
+		}
+	}
+	return result
+}

pkg/handlers/health.go

@@ -0,0 +1,29 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"time"
+
+	"neomovies-api/pkg/models"
+)
+
+func HealthCheck(w http.ResponseWriter, r *http.Request) {
+	health := map[string]interface{}{
+		"status":    "OK",
+		"timestamp": time.Now().UTC(),
+		"service":   "neomovies-api",
+		"version":   "2.0.0",
+		"uptime":    time.Since(startTime),
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(http.StatusOK)
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Message: "API is running",
+		Data:    health,
+	})
+}
+
+var startTime = time.Now()

pkg/handlers/images.go

@@ -0,0 +1,147 @@
+package handlers
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/gorilla/mux"
+)
+
+type ImagesHandler struct{}
+
+func NewImagesHandler() *ImagesHandler {
+	return &ImagesHandler{}
+}
+
+const TMDB_IMAGE_BASE_URL = "https://image.tmdb.org/t/p"
+
+func (h *ImagesHandler) GetImage(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	size := vars["size"]
+	imagePath := vars["path"]
+
+	if size == "" || imagePath == "" {
+		http.Error(w, "Size and path are required", http.StatusBadRequest)
+		return
+	}
+
+	// Если запрашивается placeholder, возвращаем локальный файл
+	if imagePath == "placeholder.jpg" {
+		h.servePlaceholder(w, r)
+		return
+	}
+
+	// Проверяем размер изображения
+	validSizes := []string{"w92", "w154", "w185", "w342", "w500", "w780", "original"}
+	if !h.isValidSize(size, validSizes) {
+		size = "original"
+	}
+
+	// Формируем URL изображения
+	imageURL := fmt.Sprintf("%s/%s/%s", TMDB_IMAGE_BASE_URL, size, imagePath)
+
+	// Получаем изображение
+	resp, err := http.Get(imageURL)
+	if err != nil {
+		h.servePlaceholder(w, r)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		h.servePlaceholder(w, r)
+		return
+	}
+
+	// Устанавливаем заголовки
+	if contentType := resp.Header.Get("Content-Type"); contentType != "" {
+		w.Header().Set("Content-Type", contentType)
+	}
+	w.Header().Set("Cache-Control", "public, max-age=31536000") // кэшируем на 1 год
+
+	// Передаем изображение клиенту
+	_, err = io.Copy(w, resp.Body)
+	if err != nil {
+		// Если ошибка при копировании, отдаем placeholder
+		h.servePlaceholder(w, r)
+		return
+	}
+}
+
+func (h *ImagesHandler) servePlaceholder(w http.ResponseWriter, r *http.Request) {
+	// Попробуем найти placeholder изображение
+	placeholderPaths := []string{
+		"./assets/placeholder.jpg",
+		"./public/images/placeholder.jpg",
+		"./static/placeholder.jpg",
+	}
+
+	var placeholderPath string
+	for _, path := range placeholderPaths {
+		if _, err := os.Stat(path); err == nil {
+			placeholderPath = path
+			break
+		}
+	}
+
+	if placeholderPath == "" {
+		// Если placeholder не найден, создаем простую SVG заглушку
+		h.serveSVGPlaceholder(w, r)
+		return
+	}
+
+	file, err := os.Open(placeholderPath)
+	if err != nil {
+		h.serveSVGPlaceholder(w, r)
+		return
+	}
+	defer file.Close()
+
+	// Определяем content-type по расширению
+	ext := strings.ToLower(filepath.Ext(placeholderPath))
+	switch ext {
+	case ".jpg", ".jpeg":
+		w.Header().Set("Content-Type", "image/jpeg")
+	case ".png":
+		w.Header().Set("Content-Type", "image/png")
+	case ".gif":
+		w.Header().Set("Content-Type", "image/gif")
+	case ".webp":
+		w.Header().Set("Content-Type", "image/webp")
+	default:
+		w.Header().Set("Content-Type", "image/jpeg")
+	}
+
+	w.Header().Set("Cache-Control", "public, max-age=3600") // кэшируем placeholder на 1 час
+
+	_, err = io.Copy(w, file)
+	if err != nil {
+		h.serveSVGPlaceholder(w, r)
+	}
+}
+
+func (h *ImagesHandler) serveSVGPlaceholder(w http.ResponseWriter, r *http.Request) {
+	svgPlaceholder := `<svg width="300" height="450" xmlns="http://www.w3.org/2000/svg">
+		<rect width="100%" height="100%" fill="#f0f0f0"/>
+		<text x="50%" y="50%" dominant-baseline="middle" text-anchor="middle" font-family="Arial, sans-serif" font-size="16" fill="#666">
+			Изображение не найдено
+		</text>
+	</svg>`
+
+	w.Header().Set("Content-Type", "image/svg+xml")
+	w.Header().Set("Cache-Control", "public, max-age=3600")
+	w.Write([]byte(svgPlaceholder))
+}
+
+func (h *ImagesHandler) isValidSize(size string, validSizes []string) bool {
+	for _, validSize := range validSizes {
+		if size == validSize {
+			return true
+		}
+	}
+	return false
+}

pkg/handlers/movie.go

@@ -0,0 +1,294 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"github.com/gorilla/mux"
+
+	"neomovies-api/pkg/middleware"
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type MovieHandler struct {
+	movieService *services.MovieService
+}
+
+func NewMovieHandler(movieService *services.MovieService) *MovieHandler {
+	return &MovieHandler{
+		movieService: movieService,
+	}
+}
+
+func (h *MovieHandler) Search(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("query")
+	if query == "" {
+		http.Error(w, "Query parameter is required", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	region := r.URL.Query().Get("region")
+	year := getIntQuery(r, "year", 0)
+
+	movies, err := h.movieService.Search(query, page, language, region, year)
+	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:    movies,
+	})
+}
+
+func (h *MovieHandler) GetByID(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	language := r.URL.Query().Get("language")
+
+	movie, err := h.movieService.GetByID(id, 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:    movie,
+	})
+}
+
+func (h *MovieHandler) Popular(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	region := r.URL.Query().Get("region")
+
+	movies, err := h.movieService.GetPopular(page, language, region)
+	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:    movies,
+	})
+}
+
+func (h *MovieHandler) TopRated(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	region := r.URL.Query().Get("region")
+
+	movies, err := h.movieService.GetTopRated(page, language, region)
+	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:    movies,
+	})
+}
+
+func (h *MovieHandler) Upcoming(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	region := r.URL.Query().Get("region")
+
+	movies, err := h.movieService.GetUpcoming(page, language, region)
+	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:    movies,
+	})
+}
+
+func (h *MovieHandler) NowPlaying(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	region := r.URL.Query().Get("region")
+
+	movies, err := h.movieService.GetNowPlaying(page, language, region)
+	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:    movies,
+	})
+}
+
+func (h *MovieHandler) GetRecommendations(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	movies, err := h.movieService.GetRecommendations(id, 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:    movies,
+	})
+}
+
+func (h *MovieHandler) GetSimilar(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	movies, err := h.movieService.GetSimilar(id, 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:    movies,
+	})
+}
+
+func (h *MovieHandler) GetFavorites(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	language := r.URL.Query().Get("language")
+
+	movies, err := h.movieService.GetFavorites(userID, 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:    movies,
+	})
+}
+
+func (h *MovieHandler) AddToFavorites(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	vars := mux.Vars(r)
+	movieID := vars["id"]
+
+	err := h.movieService.AddToFavorites(userID, movieID)
+	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,
+		Message: "Movie added to favorites",
+	})
+}
+
+func (h *MovieHandler) RemoveFromFavorites(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	vars := mux.Vars(r)
+	movieID := vars["id"]
+
+	err := h.movieService.RemoveFromFavorites(userID, movieID)
+	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,
+		Message: "Movie removed from favorites",
+	})
+}
+
+func (h *MovieHandler) GetExternalIDs(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid movie ID", http.StatusBadRequest)
+		return
+	}
+
+	externalIDs, err := h.movieService.GetExternalIDs(id)
+	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:    externalIDs,
+	})
+}
+
+func getIntQuery(r *http.Request, key string, defaultValue int) int {
+	str := r.URL.Query().Get(key)
+	if str == "" {
+		return defaultValue
+	}
+	
+	value, err := strconv.Atoi(str)
+	if err != nil {
+		return defaultValue
+	}
+	
+	return value
+}

pkg/handlers/players.go

@@ -0,0 +1,142 @@
+package handlers
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+
+	"neomovies-api/pkg/config"
+	"github.com/gorilla/mux"
+)
+
+type PlayersHandler struct {
+	config *config.Config
+}
+
+func NewPlayersHandler(cfg *config.Config) *PlayersHandler {
+	return &PlayersHandler{
+		config: cfg,
+	}
+}
+
+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)
+	
+	imdbID := vars["imdb_id"]
+	if imdbID == "" {
+		log.Printf("Error: imdb_id is empty")
+		http.Error(w, "imdb_id path param is required", http.StatusBadRequest)
+		return
+	}
+	
+	log.Printf("Processing imdb_id: %s", imdbID)
+	
+	if h.config.AllohaToken == "" {
+		log.Printf("Error: ALLOHA_TOKEN is missing")
+		http.Error(w, "Server misconfiguration: ALLOHA_TOKEN missing", http.StatusInternalServerError)
+		return
+	}
+	
+	idParam := fmt.Sprintf("imdb=%s", url.QueryEscape(imdbID))
+	apiURL := fmt.Sprintf("https://api.alloha.tv/?token=%s&%s", h.config.AllohaToken, idParam)
+	log.Printf("Calling Alloha API: %s", apiURL)
+	
+	resp, err := http.Get(apiURL)
+	if err != nil {
+		log.Printf("Error calling Alloha API: %v", err)
+		http.Error(w, "Failed to fetch from Alloha API", http.StatusInternalServerError)
+		return
+	}
+	defer resp.Body.Close()
+	
+	log.Printf("Alloha API response status: %d", resp.StatusCode)
+	
+	if resp.StatusCode != http.StatusOK {
+		http.Error(w, fmt.Sprintf("Alloha API error: %d", resp.StatusCode), http.StatusBadGateway)
+		return
+	}
+	
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Printf("Error reading Alloha response: %v", err)
+		http.Error(w, "Failed to read Alloha response", http.StatusInternalServerError)
+		return
+	}
+	
+	log.Printf("Alloha API response body: %s", string(body))
+	
+	var allohaResponse struct {
+		Status string `json:"status"`
+		Data struct {
+			Iframe string `json:"iframe"`
+		} `json:"data"`
+	}
+	
+	if err := json.Unmarshal(body, &allohaResponse); err != nil {
+		log.Printf("Error unmarshaling JSON: %v", err)
+		http.Error(w, "Invalid JSON from Alloha", http.StatusBadGateway)
+		return
+	}
+	
+	if allohaResponse.Status != "success" || allohaResponse.Data.Iframe == "" {
+		log.Printf("Video not found or empty iframe")
+		http.Error(w, "Video not found", http.StatusNotFound)
+		return
+	}
+	
+	iframeCode := allohaResponse.Data.Iframe
+	if !strings.Contains(iframeCode, "<") {
+		iframeCode = fmt.Sprintf(`<iframe src="%s" allowfullscreen style="border:none;width:100%%;height:100%%"></iframe>`, iframeCode)
+	}
+	
+	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)
+	
+	// Авто-исправление экранированных кавычек
+	htmlDoc = strings.ReplaceAll(htmlDoc, `\"`, `"`)
+	htmlDoc = strings.ReplaceAll(htmlDoc, `\'`, `'`)
+	
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte(htmlDoc))
+	
+	log.Printf("Successfully served Alloha player for imdb_id: %s", imdbID)
+}
+
+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)
+	
+	imdbID := vars["imdb_id"]
+	if imdbID == "" {
+		log.Printf("Error: imdb_id is empty")
+		http.Error(w, "imdb_id path param is required", http.StatusBadRequest)
+		return
+	}
+	
+	log.Printf("Processing imdb_id: %s", imdbID)
+	
+	if h.config.LumexURL == "" {
+		log.Printf("Error: LUMEX_URL is missing")
+		http.Error(w, "Server misconfiguration: LUMEX_URL missing", http.StatusInternalServerError)
+		return
+	}
+	
+	url := fmt.Sprintf("%s?imdb_id=%s", h.config.LumexURL, url.QueryEscape(imdbID))
+	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)
+	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)
+}

pkg/handlers/reactions.go

@@ -0,0 +1,171 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/gorilla/mux"
+
+	"neomovies-api/pkg/middleware"
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type ReactionsHandler struct {
+	reactionsService *services.ReactionsService
+}
+
+func NewReactionsHandler(reactionsService *services.ReactionsService) *ReactionsHandler {
+	return &ReactionsHandler{
+		reactionsService: reactionsService,
+	}
+}
+
+// Получить счетчики реакций для медиа (публичный эндпоинт)
+func (h *ReactionsHandler) GetReactionCounts(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	mediaType := vars["mediaType"]
+	mediaID := vars["mediaId"]
+
+	if mediaType == "" || mediaID == "" {
+		http.Error(w, "Media type and ID are required", http.StatusBadRequest)
+		return
+	}
+
+	counts, err := h.reactionsService.GetReactionCounts(mediaType, mediaID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(counts)
+}
+
+// Получить реакцию текущего пользователя (требует авторизации)
+func (h *ReactionsHandler) GetMyReaction(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	vars := mux.Vars(r)
+	mediaType := vars["mediaType"]
+	mediaID := vars["mediaId"]
+
+	if mediaType == "" || mediaID == "" {
+		http.Error(w, "Media type and ID are required", http.StatusBadRequest)
+		return
+	}
+
+	reaction, err := h.reactionsService.GetUserReaction(userID, mediaType, mediaID)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if reaction == nil {
+		json.NewEncoder(w).Encode(map[string]interface{}{})
+	} else {
+		json.NewEncoder(w).Encode(reaction)
+	}
+}
+
+// Установить реакцию пользователя (требует авторизации)
+func (h *ReactionsHandler) SetReaction(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	vars := mux.Vars(r)
+	mediaType := vars["mediaType"]
+	mediaID := vars["mediaId"]
+
+	if mediaType == "" || mediaID == "" {
+		http.Error(w, "Media type and ID are required", http.StatusBadRequest)
+		return
+	}
+
+	var request struct {
+		Type string `json:"type"`
+	}
+
+	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+
+	if request.Type == "" {
+		http.Error(w, "Reaction type is required", http.StatusBadRequest)
+		return
+	}
+
+	err := h.reactionsService.SetUserReaction(userID, mediaType, mediaID, request.Type)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Message: "Reaction set successfully",
+	})
+}
+
+// Удалить реакцию пользователя (требует авторизации)
+func (h *ReactionsHandler) RemoveReaction(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	vars := mux.Vars(r)
+	mediaType := vars["mediaType"]
+	mediaID := vars["mediaId"]
+
+	if mediaType == "" || mediaID == "" {
+		http.Error(w, "Media type and ID are required", http.StatusBadRequest)
+		return
+	}
+
+	err := h.reactionsService.RemoveUserReaction(userID, mediaType, mediaID)
+	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,
+		Message: "Reaction removed successfully",
+	})
+}
+
+// Получить все реакции пользователя (требует авторизации)
+func (h *ReactionsHandler) GetMyReactions(w http.ResponseWriter, r *http.Request) {
+	userID, ok := middleware.GetUserIDFromContext(r.Context())
+	if !ok {
+		http.Error(w, "User ID not found in context", http.StatusInternalServerError)
+		return
+	}
+
+	limit := getIntQuery(r, "limit", 50)
+
+	reactions, err := h.reactionsService.GetUserReactions(userID, limit)
+	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:    reactions,
+	})
+}

pkg/handlers/search.go

@@ -0,0 +1,45 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type SearchHandler struct {
+	tmdbService *services.TMDBService
+}
+
+func NewSearchHandler(tmdbService *services.TMDBService) *SearchHandler {
+	return &SearchHandler{
+		tmdbService: tmdbService,
+	}
+}
+
+func (h *SearchHandler) MultiSearch(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("query")
+	if query == "" {
+		http.Error(w, "Query parameter is required", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	if language == "" {
+		language = "ru-RU"
+	}
+
+	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/torrents.go

@@ -0,0 +1,367 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+	"strings"
+
+	"github.com/gorilla/mux"
+
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type TorrentsHandler struct {
+	torrentService *services.TorrentService
+	tmdbService    *services.TMDBService
+}
+
+func NewTorrentsHandler(torrentService *services.TorrentService, tmdbService *services.TMDBService) *TorrentsHandler {
+	return &TorrentsHandler{
+		torrentService: torrentService,
+		tmdbService:    tmdbService,
+	}
+}
+
+// SearchTorrents - поиск торрентов по IMDB ID
+func (h *TorrentsHandler) SearchTorrents(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	imdbID := vars["imdbId"]
+
+	if imdbID == "" {
+		http.Error(w, "IMDB ID is required", http.StatusBadRequest)
+		return
+	}
+
+	// Параметры запроса
+	mediaType := r.URL.Query().Get("type")
+	if mediaType == "" {
+		mediaType = "movie"
+	}
+
+	// Создаем опции поиска
+	options := &models.TorrentSearchOptions{
+		ContentType: mediaType,
+	}
+
+	// Качество
+	if quality := r.URL.Query().Get("quality"); quality != "" {
+		options.Quality = strings.Split(quality, ",")
+	}
+
+	// Минимальное и максимальное качество
+	options.MinQuality = r.URL.Query().Get("minQuality")
+	options.MaxQuality = r.URL.Query().Get("maxQuality")
+
+	// Исключаемые качества
+	if excludeQualities := r.URL.Query().Get("excludeQualities"); excludeQualities != "" {
+		options.ExcludeQualities = strings.Split(excludeQualities, ",")
+	}
+
+	// HDR
+	if hdr := r.URL.Query().Get("hdr"); hdr != "" {
+		if hdrBool, err := strconv.ParseBool(hdr); err == nil {
+			options.HDR = &hdrBool
+		}
+	}
+
+	// HEVC
+	if hevc := r.URL.Query().Get("hevc"); hevc != "" {
+		if hevcBool, err := strconv.ParseBool(hevc); err == nil {
+			options.HEVC = &hevcBool
+		}
+	}
+
+	// Сортировка
+	options.SortBy = r.URL.Query().Get("sortBy")
+	if options.SortBy == "" {
+		options.SortBy = "seeders"
+	}
+
+	options.SortOrder = r.URL.Query().Get("sortOrder")
+	if options.SortOrder == "" {
+		options.SortOrder = "desc"
+	}
+
+	// Группировка
+	if groupByQuality := r.URL.Query().Get("groupByQuality"); groupByQuality == "true" {
+		options.GroupByQuality = true
+	}
+
+	if groupBySeason := r.URL.Query().Get("groupBySeason"); groupBySeason == "true" {
+		options.GroupBySeason = true
+	}
+
+	// Сезон для сериалов
+	if season := r.URL.Query().Get("season"); season != "" {
+		if seasonInt, err := strconv.Atoi(season); err == nil {
+			options.Season = &seasonInt
+		}
+	}
+
+	// Поиск торрентов
+	results, err := h.torrentService.SearchTorrentsByIMDbID(h.tmdbService, imdbID, mediaType, options)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Формируем ответ с группировкой если необходимо
+	response := map[string]interface{}{
+		"imdbId": imdbID,
+		"type":   mediaType,
+		"total":  results.Total,
+	}
+
+	if options.Season != nil {
+		response["season"] = *options.Season
+	}
+
+	// Применяем группировку если запрошена
+	if options.GroupByQuality && options.GroupBySeason {
+		// Группируем сначала по сезонам, затем по качеству внутри каждого сезона
+		seasonGroups := h.torrentService.GroupBySeason(results.Results)
+		finalGroups := make(map[string]map[string][]models.TorrentResult)
+		
+		for season, torrents := range seasonGroups {
+			qualityGroups := h.torrentService.GroupByQuality(torrents)
+			finalGroups[season] = qualityGroups
+		}
+		
+		response["grouped"] = true
+		response["groups"] = finalGroups
+	} else if options.GroupByQuality {
+		groups := h.torrentService.GroupByQuality(results.Results)
+		response["grouped"] = true
+		response["groups"] = groups
+	} else if options.GroupBySeason {
+		groups := h.torrentService.GroupBySeason(results.Results)
+		response["grouped"] = true
+		response["groups"] = groups
+	} else {
+		response["grouped"] = false
+		response["results"] = results.Results
+	}
+
+	if len(results.Results) == 0 {
+		response["error"] = "No torrents found for this IMDB ID"
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusNotFound)
+		json.NewEncoder(w).Encode(response)
+		return
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}
+
+// SearchMovies - поиск фильмов по названию
+func (h *TorrentsHandler) SearchMovies(w http.ResponseWriter, r *http.Request) {
+	title := r.URL.Query().Get("title")
+	originalTitle := r.URL.Query().Get("originalTitle")
+	year := r.URL.Query().Get("year")
+
+	if title == "" && originalTitle == "" {
+		http.Error(w, "Title or original title is required", http.StatusBadRequest)
+		return
+	}
+
+	results, err := h.torrentService.SearchMovies(title, originalTitle, year)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := map[string]interface{}{
+		"title":         title,
+		"originalTitle": originalTitle,
+		"year":          year,
+		"type":          "movie",
+		"total":         results.Total,
+		"results":       results.Results,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}
+
+// SearchSeries - поиск сериалов по названию с поддержкой сезонов
+func (h *TorrentsHandler) SearchSeries(w http.ResponseWriter, r *http.Request) {
+	title := r.URL.Query().Get("title")
+	originalTitle := r.URL.Query().Get("originalTitle")
+	year := r.URL.Query().Get("year")
+
+	if title == "" && originalTitle == "" {
+		http.Error(w, "Title or original title is required", http.StatusBadRequest)
+		return
+	}
+
+	var season *int
+	if seasonStr := r.URL.Query().Get("season"); seasonStr != "" {
+		if seasonInt, err := strconv.Atoi(seasonStr); err == nil {
+			season = &seasonInt
+		}
+	}
+
+	results, err := h.torrentService.SearchSeries(title, originalTitle, year, season)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := map[string]interface{}{
+		"title":         title,
+		"originalTitle": originalTitle,
+		"year":          year,
+		"type":          "series",
+		"total":         results.Total,
+		"results":       results.Results,
+	}
+
+	if season != nil {
+		response["season"] = *season
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}
+
+// SearchAnime - поиск аниме по названию
+func (h *TorrentsHandler) SearchAnime(w http.ResponseWriter, r *http.Request) {
+	title := r.URL.Query().Get("title")
+	originalTitle := r.URL.Query().Get("originalTitle")
+	year := r.URL.Query().Get("year")
+
+	if title == "" && originalTitle == "" {
+		http.Error(w, "Title or original title is required", http.StatusBadRequest)
+		return
+	}
+
+	results, err := h.torrentService.SearchAnime(title, originalTitle, year)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := map[string]interface{}{
+		"title":         title,
+		"originalTitle": originalTitle,
+		"year":          year,
+		"type":          "anime",
+		"total":         results.Total,
+		"results":       results.Results,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}
+
+// GetAvailableSeasons - получение доступных сезонов для сериала
+func (h *TorrentsHandler) GetAvailableSeasons(w http.ResponseWriter, r *http.Request) {
+	title := r.URL.Query().Get("title")
+	originalTitle := r.URL.Query().Get("originalTitle")
+	year := r.URL.Query().Get("year")
+
+	if title == "" && originalTitle == "" {
+		http.Error(w, "Title or original title is required", http.StatusBadRequest)
+		return
+	}
+
+	seasons, err := h.torrentService.GetAvailableSeasons(title, originalTitle, year)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	response := map[string]interface{}{
+		"title":         title,
+		"originalTitle": originalTitle,
+		"year":          year,
+		"seasons":       seasons,
+		"total":         len(seasons),
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}
+
+// SearchByQuery - универсальный поиск торрентов
+func (h *TorrentsHandler) SearchByQuery(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("query")
+	if query == "" {
+		http.Error(w, "Query is required", http.StatusBadRequest)
+		return
+	}
+
+	contentType := r.URL.Query().Get("type")
+	if contentType == "" {
+		contentType = "movie"
+	}
+
+	year := r.URL.Query().Get("year")
+
+	// Формируем параметры поиска
+	params := map[string]string{
+		"query": query,
+	}
+
+	if year != "" {
+		params["year"] = year
+	}
+
+	// Устанавливаем тип контента и категорию
+	switch contentType {
+	case "movie":
+		params["is_serial"] = "1"
+		params["category"] = "2000"
+	case "series", "tv":
+		params["is_serial"] = "2"
+		params["category"] = "5000"
+	case "anime":
+		params["is_serial"] = "5"
+		params["category"] = "5070"
+	}
+
+	results, err := h.torrentService.SearchTorrents(params)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Применяем фильтрацию по типу контента
+	options := &models.TorrentSearchOptions{
+		ContentType: contentType,
+	}
+	results.Results = h.torrentService.FilterByContentType(results.Results, options.ContentType)
+	results.Total = len(results.Results)
+
+	response := map[string]interface{}{
+		"query":   query,
+		"type":    contentType,
+		"year":    year,
+		"total":   results.Total,
+		"results": results.Results,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(models.APIResponse{
+		Success: true,
+		Data:    response,
+	})
+}

pkg/handlers/tv.go

@@ -0,0 +1,206 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+	"strconv"
+
+	"github.com/gorilla/mux"
+
+	"neomovies-api/pkg/models"
+	"neomovies-api/pkg/services"
+)
+
+type TVHandler struct {
+	tvService *services.TVService
+}
+
+func NewTVHandler(tvService *services.TVService) *TVHandler {
+	return &TVHandler{
+		tvService: tvService,
+	}
+}
+
+func (h *TVHandler) Search(w http.ResponseWriter, r *http.Request) {
+	query := r.URL.Query().Get("query")
+	if query == "" {
+		http.Error(w, "Query parameter is required", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+	year := getIntQuery(r, "first_air_date_year", 0)
+
+	tvShows, err := h.tvService.Search(query, page, language, year)
+	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:    tvShows,
+	})
+}
+
+func (h *TVHandler) GetByID(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+		return
+	}
+
+	language := r.URL.Query().Get("language")
+
+	tvShow, err := h.tvService.GetByID(id, 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:    tvShow,
+	})
+}
+
+func (h *TVHandler) Popular(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetPopular(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:    tvShows,
+	})
+}
+
+func (h *TVHandler) TopRated(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetTopRated(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:    tvShows,
+	})
+}
+
+func (h *TVHandler) OnTheAir(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetOnTheAir(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:    tvShows,
+	})
+}
+
+func (h *TVHandler) AiringToday(w http.ResponseWriter, r *http.Request) {
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetAiringToday(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:    tvShows,
+	})
+}
+
+func (h *TVHandler) GetRecommendations(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetRecommendations(id, 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:    tvShows,
+	})
+}
+
+func (h *TVHandler) GetSimilar(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+		return
+	}
+
+	page := getIntQuery(r, "page", 1)
+	language := r.URL.Query().Get("language")
+
+	tvShows, err := h.tvService.GetSimilar(id, 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:    tvShows,
+	})
+}
+
+func (h *TVHandler) GetExternalIDs(w http.ResponseWriter, r *http.Request) {
+	vars := mux.Vars(r)
+	id, err := strconv.Atoi(vars["id"])
+	if err != nil {
+		http.Error(w, "Invalid TV show ID", http.StatusBadRequest)
+		return
+	}
+
+	externalIDs, err := h.tvService.GetExternalIDs(id)
+	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:    externalIDs,
+	})
+}