nl-video-api/internal/controller/movie/movie.go

package movie

import (
	"strconv"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/net/ghttp"
	"nl-video-api/internal/service/movie"
	"nl-video-api/utility/response"
)

// MovieController 影片控制器
type MovieController struct{}

var Movie = &MovieController{}

// Create 创建影片
func (c *MovieController) Create(r *ghttp.Request) {
	var req *movie.MovieCreateReq
	if err := r.Parse(&req); err != nil {
		response.Error(r, 1001, "参数解析失败: "+err.Error())
		return
	}

	movieService := movie.NewMovieService()
	err := movieService.Create(r.Context(), req)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "创建成功",
	})
}

// Update 更新影片
func (c *MovieController) Update(r *ghttp.Request) {
	var req *movie.MovieUpdateReq
	if err := r.Parse(&req); err != nil {
		response.Error(r, 1001, "参数解析失败: "+err.Error())
		return
	}

	// 从URL路径获取ID
	if req.Id == 0 {
		idStr := r.Get("id").String()
		if id, err := strconv.Atoi(idStr); err == nil {
			req.Id = id
		}
	}

	if req.Id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	movieService := movie.NewMovieService()
	err := movieService.Update(r.Context(), req)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "更新成功",
	})
}

// GetById 获取影片详情
func (c *MovieController) GetById(r *ghttp.Request) {
	idStr := r.Get("id").String()
	id, err := strconv.Atoi(idStr)
	if err != nil || id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	movieService := movie.NewMovieService()
	movieDetail, err := movieService.GetById(r.Context(), &movie.MovieDetailReq{Id: id})
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    movieDetail,
	})
}

// GetList 获取影片列表
func (c *MovieController) GetList(r *ghttp.Request) {
	var req *movie.MovieListReq
	if err := r.Parse(&req); err != nil {
		response.Error(r, 1001, "参数解析失败: "+err.Error())
		return
	}

	// 设置默认分页参数
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 10
	}

	movieService := movie.NewMovieService()
	result, err := movieService.GetList(r.Context(), req)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    result,
	})
}

// Delete 删除影片
func (c *MovieController) Delete(r *ghttp.Request) {
	idStr := r.Get("id").String()
	id, err := strconv.Atoi(idStr)
	if err != nil || id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	movieService := movie.NewMovieService()
	err = movieService.Delete(r.Context(), &movie.MovieDeleteReq{Id: id})
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "删除成功",
	})
}

// GetHot 获取热门影片
func (c *MovieController) GetHot(r *ghttp.Request) {
	limitStr := r.Get("limit", "10").String()
	limit, err := strconv.Atoi(limitStr)
	if err != nil || limit <= 0 {
		limit = 10
	}

	movieService := movie.NewMovieService()
	movies, err := movieService.GetHotMovies(r.Context(), limit)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    movies,
	})
}

// GetRecommend 获取推荐影片
func (c *MovieController) GetRecommend(r *ghttp.Request) {
	limitStr := r.Get("limit", "10").String()
	limit, err := strconv.Atoi(limitStr)
	if err != nil || limit <= 0 {
		limit = 10
	}

	movieService := movie.NewMovieService()
	movies, err := movieService.GetRecommendMovies(r.Context(), limit)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    movies,
	})
}

// GetNew 获取最新影片
func (c *MovieController) GetNew(r *ghttp.Request) {
	limitStr := r.Get("limit", "10").String()
	limit, err := strconv.Atoi(limitStr)
	if err != nil || limit <= 0 {
		limit = 10
	}

	movieService := movie.NewMovieService()
	movies, err := movieService.GetNewMovies(r.Context(), limit)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    movies,
	})
}

// Search 搜索影片
func (c *MovieController) Search(r *ghttp.Request) {
	keyword := r.Get("keyword").String()
	if keyword == "" {
		response.Error(r, 1001, "搜索关键词不能为空")
		return
	}

	pageStr := r.Get("page", "1").String()
	page, err := strconv.Atoi(pageStr)
	if err != nil || page <= 0 {
		page = 1
	}

	pageSizeStr := r.Get("page_size", "10").String()
	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize <= 0 {
		pageSize = 10
	}

	movieService := movie.NewMovieService()
	movies, total, err := movieService.SearchMovies(r.Context(), keyword, page, pageSize)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "搜索成功",
		"data": g.Map{
			"list":      movies,
			"total":     total,
			"page":      page,
			"page_size": pageSize,
			"keyword":   keyword,
		},
	})
}

// GetByCategory 根据分类获取影片
func (c *MovieController) GetByCategory(r *ghttp.Request) {
	categoryIdStr := r.Get("category_id").String()
	categoryId, err := strconv.Atoi(categoryIdStr)
	if err != nil || categoryId <= 0 {
		response.Error(r, 1001, "分类ID无效")
		return
	}

	pageStr := r.Get("page", "1").String()
	page, err := strconv.Atoi(pageStr)
	if err != nil || page <= 0 {
		page = 1
	}

	pageSizeStr := r.Get("page_size", "10").String()
	pageSize, err := strconv.Atoi(pageSizeStr)
	if err != nil || pageSize <= 0 {
		pageSize = 10
	}

	movieService := movie.NewMovieService()
	movies, total, err := movieService.GetMoviesByCategory(r.Context(), categoryId, page, pageSize)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data": g.Map{
			"list":        movies,
			"total":       total,
			"page":        page,
			"page_size":   pageSize,
			"category_id": categoryId,
		},
	})
}

// UpdateViewCount 更新观看次数
func (c *MovieController) UpdateViewCount(r *ghttp.Request) {
	idStr := r.Get("id").String()
	id, err := strconv.Atoi(idStr)
	if err != nil || id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	movieService := movie.NewMovieService()
	err = movieService.UpdateViewCount(r.Context(), id)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "更新成功",
	})
}

// UpdateLikeCount 更新点赞数
func (c *MovieController) UpdateLikeCount(r *ghttp.Request) {
	idStr := r.Get("id").String()
	id, err := strconv.Atoi(idStr)
	if err != nil || id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	incrementStr := r.Get("increment", "1").String()
	increment, err := strconv.Atoi(incrementStr)
	if err != nil {
		increment = 1
	}

	movieService := movie.NewMovieService()
	err = movieService.UpdateLikeCount(r.Context(), id, increment)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "更新成功",
	})
}

// UpdateCollectCount 更新收藏数
func (c *MovieController) UpdateCollectCount(r *ghttp.Request) {
	idStr := r.Get("id").String()
	id, err := strconv.Atoi(idStr)
	if err != nil || id <= 0 {
		response.Error(r, 1001, "影片ID无效")
		return
	}

	incrementStr := r.Get("increment", "1").String()
	increment, err := strconv.Atoi(incrementStr)
	if err != nil {
		increment = 1
	}

	movieService := movie.NewMovieService()
	err = movieService.UpdateCollectCount(r.Context(), id, increment)
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "更新成功",
	})
}

// GetStatistics 获取影片统计
func (c *MovieController) GetStatistics(r *ghttp.Request) {
	movieService := movie.NewMovieService()
	stats, err := movieService.GetStatistics(r.Context())
	if err != nil {
		response.Error(r, 1002, err.Error())
		return
	}

	response.Success(r, g.Map{
		"message": "获取成功",
		"data":    stats,
	})
}

// BatchUpdate 批量更新影片
func (c *MovieController) BatchUpdate(r *ghttp.Request) {
	var req struct {
		Ids    []int `json:"ids" v:"required#影片ID列表不能为空"`
		Status *int  `json:"status"`
		IsVip  *int  `json:"is_vip"`
	}
	
	if err := r.Parse(&req); err != nil {
		response.Error(r, 1001, "参数解析失败: "+err.Error())
		return
	}

	if len(req.Ids) == 0 {
		response.Error(r, 1001, "影片ID列表不能为空")
		return
	}

	// TODO: 实现批量更新逻辑
	response.Success(r, g.Map{
		"message": "批量更新成功",
	})
}

// UploadVideo 上传视频
func (c *MovieController) UploadVideo(r *ghttp.Request) {
	// TODO: 实现视频上传逻辑
	response.Success(r, g.Map{
		"message": "视频上传成功",
		"data": g.Map{
			"url": "/uploads/videos/example.mp4",
		},
	})
}

// UploadPoster 上传海报
func (c *MovieController) UploadPoster(r *ghttp.Request) {
	// TODO: 实现海报上传逻辑
	response.Success(r, g.Map{
		"message": "海报上传成功",
		"data": g.Map{
			"url": "/uploads/posters/example.jpg",
		},
	})
}