synctv/server/handlers/movie.go

package handlers

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	"image"
	"image/color"
	"image/png"
	"math/rand"
	"net/http"
	"path/filepath"
	"strings"

	"github.com/gin-gonic/gin"
	log "github.com/sirupsen/logrus"
	"github.com/synctv-org/synctv/internal/conf"
	dbModel "github.com/synctv-org/synctv/internal/model"
	"github.com/synctv-org/synctv/internal/op"
	"github.com/synctv-org/synctv/internal/rtmp"
	"github.com/synctv-org/synctv/internal/settings"
	"github.com/synctv-org/synctv/server/handlers/proxy"
	"github.com/synctv-org/synctv/server/handlers/vendors"
	"github.com/synctv-org/synctv/server/model"
	"github.com/synctv-org/synctv/utils"
	"github.com/zijiren233/livelib/protocol/hls"
	"github.com/zijiren233/livelib/protocol/httpflv"
)

func GetPageItems[T any](ctx *gin.Context, items []T) ([]T, error) {
	page, max, err := utils.GetPageAndMax(ctx)
	if err != nil {
		return nil, err
	}

	return utils.GetPageItems(items, page, max), nil
}

func genMovieInfo(
	ctx context.Context,
	room *op.Room,
	user *op.User,
	opMovie *op.Movie,
	userAgent,
	userToken string,
) (*model.Movie, error) {
	if opMovie == nil || opMovie.ID == "" {
		return &model.Movie{}, nil
	}
	if opMovie.IsFolder {
		if !opMovie.IsDynamicFolder() {
			return nil, errors.New("movie is static folder, can't get movie info")
		}
	}
	movie := opMovie.Movie.Clone()
	if movie.MovieBase.Type == "" && movie.MovieBase.Url != "" {
		movie.MovieBase.Type = utils.GetUrlExtension(movie.MovieBase.Url)
	}
	if movie.MovieBase.VendorInfo.Vendor != "" {
		vendor, err := vendors.NewVendorService(room, opMovie)
		if err != nil {
			return nil, err
		}
		movie, err = vendor.GenMovieInfo(ctx, user, userAgent, userToken)
		if err != nil {
			return nil, err
		}
	} else if movie.MovieBase.RtmpSource {
		movie.MovieBase.Url = fmt.Sprintf("/api/room/movie/live/hls/list/%s.m3u8?token=%s&roomId=%s", movie.ID, userToken, opMovie.RoomID)
		movie.MovieBase.Type = "m3u8"
		movie.MoreSources = append(movie.MoreSources, &dbModel.MoreSource{
			Name: "flv",
			Url:  fmt.Sprintf("/api/room/movie/live/flv/%s.flv?token=%s&roomId=%s", movie.ID, userToken, opMovie.RoomID),
			Type: "flv",
		})
		movie.MovieBase.Headers = nil
	} else if movie.MovieBase.Live && movie.MovieBase.Proxy {
		if !utils.IsM3u8Url(movie.MovieBase.Url) {
			movie.MoreSources = append(movie.MoreSources, &dbModel.MoreSource{
				Name: "flv",
				Url:  fmt.Sprintf("/api/room/movie/live/flv/%s.flv?token=%s&roomId=%s", movie.ID, userToken, opMovie.RoomID),
				Type: "flv",
			})
		}
		movie.MovieBase.Url = fmt.Sprintf("/api/room/movie/live/hls/list/%s.m3u8?token=%s&roomId=%s", movie.ID, userToken, opMovie.RoomID)
		movie.MovieBase.Type = "m3u8"
		movie.MovieBase.Headers = nil
	} else if movie.MovieBase.Proxy {
		movie.MovieBase.Url = fmt.Sprintf("/api/room/movie/proxy/%s?token=%s&roomId=%s", movie.ID, userToken, opMovie.RoomID)
		movie.MovieBase.Headers = nil
	}
	if movie.MovieBase.Type == "" && movie.MovieBase.Url != "" {
		movie.MovieBase.Type = utils.GetUrlExtension(movie.MovieBase.Url)
	}
	for _, v := range movie.MoreSources {
		if v.Type == "" {
			v.Type = utils.GetUrlExtension(v.Url)
		}
	}
	for _, v := range movie.Subtitles {
		if v.Type == "" {
			v.Type = utils.GetUrlExtension(v.URL)
		}
	}
	resp := &model.Movie{
		Id:        movie.ID,
		CreatedAt: movie.CreatedAt.UnixMilli(),
		Base:      movie.MovieBase,
		Creator:   op.GetUserName(movie.CreatorID),
		CreatorId: movie.CreatorID,
		SubPath:   opMovie.SubPath(),
	}
	return resp, nil
}

func genCurrentRespWithCurrent(ctx context.Context, room *op.Room, user *op.User, userAgent string, userToken string) (*model.CurrentMovieResp, error) {
	current := room.Current()
	if current.Movie.ID == "" {
		return &model.CurrentMovieResp{
			Movie: &model.Movie{},
		}, nil
	}
	opMovie, err := room.GetMovieByID(current.Movie.ID)
	if err != nil {
		return nil, fmt.Errorf("get current movie error: %w", err)
	}
	mr, err := genMovieInfo(ctx, room, user, opMovie, userAgent, userToken)
	if err != nil {
		return nil, fmt.Errorf("gen current movie info error: %w", err)
	}
	resp := &model.CurrentMovieResp{
		Status:   current.UpdateStatus(),
		Movie:    mr,
		ExpireId: opMovie.ExpireId(),
	}
	return resp, nil
}

func CurrentMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	currentResp, err := genCurrentRespWithCurrent(ctx, room, user, ctx.GetHeader("User-Agent"), ctx.GetString("token"))
	if err != nil {
		log.Errorf("gen current resp error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
		return
	}

	ctx.JSON(http.StatusOK, model.NewApiDataResp(currentResp))
}

func Movies(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	if !user.HasRoomPermission(room, dbModel.PermissionGetMovieList) {
		ctx.AbortWithStatusJSON(http.StatusForbidden, model.NewApiErrorResp(dbModel.ErrNoPermission))
		return
	}

	id := ctx.Query("id")
	if len(id) != 0 && len(id) != 32 {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("id length must be 0 or 32"))
		return
	}

	page, max, err := utils.GetPageAndMax(ctx)
	if err != nil {
		log.Errorf("get page and max error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if id != "" {
		mv, err := room.GetMovieByID(id)
		if err != nil {
			log.Errorf("get room movie by id error: %v", err)
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
			return
		}
		if !mv.IsFolder {
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("parent id is not folder"))
			return
		}
		if mv.IsDynamicFolder() {
			resp, err := listVendorDynamicMovie(ctx, user, room, mv, ctx.Query("subPath"), page, max)
			if err != nil {
				log.Errorf("vendor dynamic movie list error: %v", err)
				ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
				return
			}
			ctx.JSON(http.StatusOK, model.NewApiDataResp(resp))
			return
		}
	}

	m, total, err := user.GetRoomMoviesWithPage(room, page, max, id)
	if err != nil {
		log.Errorf("get room movies with page error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
		return
	}

	paths, err := getParentMoviePath(room, id)
	if err != nil {
		log.Errorf("get parent movie path error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
		return
	}

	resp := &model.MoviesResp{
		MovieList: &model.MovieList{
			Total:  total,
			Movies: make([]*model.Movie, len(m)),
			Paths:  paths,
		},
	}

	for i, v := range m {
		resp.Movies[i] = &model.Movie{
			Id:        v.ID,
			CreatedAt: v.CreatedAt.UnixMilli(),
			Base:      v.MovieBase,
			Creator:   op.GetUserName(v.CreatorID),
			CreatorId: v.CreatorID,
		}
		// hide url and headers when proxy
		if user.ID != v.CreatorID && v.MovieBase.Proxy {
			resp.Movies[i].Base.Url = ""
			resp.Movies[i].Base.Headers = nil
		}
	}

	ctx.JSON(http.StatusOK, model.NewApiDataResp(resp))
}

func getParentMoviePath(room *op.Room, id string) ([]*model.MoviePath, error) {
	paths := []*model.MoviePath{
		{
			Name: "Home",
			ID:   "",
		},
	}
	if id == "" {
		return paths, nil
	}
	for id != "" {
		p, err := room.GetMovieByID(id)
		if err != nil {
			return nil, fmt.Errorf("get movie by id error: %w", err)
		}
		paths = append(paths, &model.MoviePath{
			Name: p.MovieBase.Name,
			ID:   p.ID,
		})
		id = p.ParentID.String()
	}
	return paths, nil
}

func listVendorDynamicMovie(ctx context.Context, reqUser *op.User, room *op.Room, movie *op.Movie, subPath string, page, max int) (*model.MoviesResp, error) {
	if reqUser.ID != movie.CreatorID {
		return nil, fmt.Errorf("list vendor dynamic folder error: %w", dbModel.ErrNoPermission)
	}

	paths, err := getParentMoviePath(room, movie.ID)
	if err != nil {
		return nil, fmt.Errorf("get parent movie path error: %w", err)
	}
	vendor, err := vendors.NewVendorService(room, movie)
	if err != nil {
		return nil, err
	}
	dynamic, err := vendor.ListDynamicMovie(ctx, reqUser, subPath, page, max)
	if err != nil {
		return nil, err
	}
	dynamic.Paths = append(paths, dynamic.Paths...)
	resp := &model.MoviesResp{
		MovieList: dynamic,
		Dynamic:   true,
	}
	return resp, nil
}

func PushMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	req := model.PushMovieReq{}
	if err := model.Decode(ctx, &req); err != nil {
		log.Errorf("push movie error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	m, err := user.AddRoomMovie(room, (*dbModel.MovieBase)(&req))
	if err != nil {
		log.Errorf("push movie error: %v", err)
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("push movie error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.JSON(http.StatusOK, model.NewApiDataResp(m))
}

func PushMovies(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	req := model.PushMoviesReq{}
	if err := model.Decode(ctx, &req); err != nil {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	var ms []*dbModel.MovieBase = make([]*dbModel.MovieBase, len(req))

	for i, v := range req {
		ms[i] = (*dbModel.MovieBase)(v)
	}

	m, err := user.AddRoomMovies(room, ms)
	if err != nil {
		log.Errorf("push movies error: %v", err)
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("push movies error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.JSON(http.StatusOK, model.NewApiDataResp(m))
}

func NewPublishKey(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)

	if !conf.Conf.Server.Rtmp.Enable {
		log.Errorf("rtmp is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("rtmp is not enabled"))
		return
	}

	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()

	req := model.IdReq{}
	if err := model.Decode(ctx, &req); err != nil {
		log.Errorf("new publish key error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}
	movie, err := room.GetMovieByID(req.Id)
	if err != nil {
		log.Errorf("new publish key error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if movie.Movie.CreatorID != user.ID {
		log.Errorf("new publish key error: %v", dbModel.ErrNoPermission)
		ctx.AbortWithStatusJSON(
			http.StatusForbidden,
			model.NewApiErrorResp(
				fmt.Errorf("new publish key error: %w", dbModel.ErrNoPermission),
			),
		)
		return
	}

	if !movie.Movie.MovieBase.RtmpSource {
		log.Errorf("new publish key error: %v", "only rtmp source movie can get publish key")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("only live movie can get publish key"))
		return
	}

	token, err := rtmp.NewRtmpAuthorization(movie.Movie.ID)
	if err != nil {
		log.Errorf("new publish key error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
		return
	}

	host := settings.CustomPublishHost.Get()
	if host == "" {
		host = HOST.Get()
	}
	if host == "" {
		host = ctx.Request.Host
	}

	ctx.JSON(http.StatusOK, model.NewApiDataResp(gin.H{
		"host":  host,
		"app":   room.ID,
		"token": token,
	}))
}

func EditMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	req := model.EditMovieReq{}
	if err := model.Decode(ctx, &req); err != nil {
		log.Errorf("edit movie error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if err := user.UpdateRoomMovie(room, req.Id, (*dbModel.MovieBase)(&req.PushMovieReq)); err != nil {
		log.Errorf("edit movie error: %v", err)
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("edit movie error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.Status(http.StatusNoContent)
}

func DelMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	req := model.IdsReq{}
	if err := model.Decode(ctx, &req); err != nil {
		log.Errorf("del movie error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	err := user.DeleteRoomMoviesByID(room, req.Ids)
	if err != nil {
		log.Errorf("del movie error: %v", err)
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("del movie error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.Status(http.StatusNoContent)
}

func ClearMovies(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()

	var req model.ClearMoviesReq
	if err := model.Decode(ctx, &req); err != nil {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if err := user.ClearRoomMoviesByParentID(room, req.ParentId); err != nil {
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("clear movies error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.Status(http.StatusNoContent)
}

func SwapMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()

	req := model.SwapMovieReq{}
	if err := model.Decode(ctx, &req); err != nil {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if err := user.SwapRoomMoviePositions(room, req.Id1, req.Id2); err != nil {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.Status(http.StatusNoContent)
}

func ChangeCurrentMovie(ctx *gin.Context) {
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	user := ctx.MustGet("user").(*op.UserEntry).Value()
	log := ctx.MustGet("log").(*log.Entry)

	req := model.SetRoomCurrentMovieReq{}
	err := model.Decode(ctx, &req)
	if err != nil {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	err = user.SetRoomCurrentMovie(room, req.Id, req.SubPath, true)
	if err != nil {
		log.Errorf("change current movie error: %v", err)
		if errors.Is(err, dbModel.ErrNoPermission) {
			ctx.AbortWithStatusJSON(
				http.StatusForbidden,
				model.NewApiErrorResp(
					fmt.Errorf("change current movie error: %w", err),
				),
			)
			return
		}
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	ctx.Status(http.StatusNoContent)
}

func ProxyMovie(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)

	if !settings.MovieProxy.Get() {
		log.Errorf("movie proxy is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("movie proxy is not enabled"))
		return
	}

	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	// user := ctx.MustGet("user").(*op.UserEntry).Value()

	m, err := room.GetMovieByID(ctx.Param("movieId"))
	if err != nil {
		log.Errorf("get movie by id error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if m.Movie.MovieBase.VendorInfo.Vendor != "" {
		vendor, err := vendors.NewVendorService(room, m)
		if err != nil {
			log.Errorf("get vendor service error: %v", err)
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
			return
		}
		vendor.ProxyMovie(ctx)
		return
	}

	if !m.Movie.MovieBase.Proxy {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("proxy is not enabled"))
		return
	}

	if m.Movie.MovieBase.Live || m.Movie.MovieBase.RtmpSource {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("this movie is live or rtmp source, not support use this method proxy"))
		return
	}

	switch m.Movie.MovieBase.Type {
	case "mpd":
		// TODO: cache mpd file
		fallthrough
	default:
		err = proxy.AuthProxyURL(ctx, m.Movie.MovieBase.Url, m.Movie.MovieBase.Type, m.Movie.MovieBase.Headers, ctx.GetString("token"), room.ID, m.ID)
		if err != nil {
			log.Errorf("proxy movie error: %v", err)
			return
		}
	}
}

func ServeM3u8(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)

	if !settings.MovieProxy.Get() {
		log.Errorf("movie proxy is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("movie proxy is not enabled"))
		return
	}

	room := ctx.MustGet("room").(*op.RoomEntry).Value()

	m, err := room.GetMovieByID(ctx.Param("movieId"))
	if err != nil {
		log.Errorf("get movie by id error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if m.Movie.MovieBase.VendorInfo.Vendor != "" {
		err := fmt.Errorf("vendor is not supported")
		log.Errorf("get vendor service error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}

	if m.Movie.MovieBase.RtmpSource {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("this movie is rtmp source, not support use this method proxy"))
		return
	}

	if !m.Movie.MovieBase.Proxy {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("proxy is not enabled"))
		return
	}

	targetToken := ctx.Param("targetToken")
	claims, err := proxy.GetM3u8Target(targetToken)
	if err != nil {
		log.Errorf("auth m3u8 error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(err))
		return
	}
	if claims.RoomId != room.ID || claims.MovieId != m.ID {
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("invalid token"))
		return
	}
	err = proxy.ProxyM3u8(ctx, claims.TargetUrl, m.Movie.MovieBase.Headers, claims.IsM3u8File, ctx.GetString("token"), room.ID, m.ID)
	if err != nil {
		log.Errorf("proxy m3u8 error: %v", err)
	}
}

// only cache mpd file
// func initDashCache(ctx context.Context, movie *dbModel.Movie) func() (any, error) {
// 	return func() (any, error) {
// 		req, err := http.NewRequestWithContext(ctx, http.MethodGet, movie.Base.Url, nil)
// 		if err != nil {
// 			return nil, err
// 		}
// 		for k, v := range movie.Base.Headers {
// 			req.Header.Set(k, v)
// 		}
// 		req.Header.Set("User-Agent", utils.UA)
// 		resp, err := uhc.Do(req)
// 		if err != nil {
// 			return nil, err
// 		}
// 		defer resp.Body.Close()
// 		b, err := io.ReadAll(resp.Body)
// 		if err != nil {
// 			return nil, err
// 		}
// 		m, err := mpd.ReadFromString(string(b))
// 		if err != nil {
// 			return nil, err
// 		}
// 		if len(m.BaseURL) != 0 && !path.IsAbs(m.BaseURL[0]) {
// 			result, err := url.JoinPath(path.Dir(movie.Base.Url), m.BaseURL[0])
// 			if err != nil {
// 				return nil, err
// 			}
// 			m.BaseURL = []string{result}
// 		}
// 		s, err := m.WriteToString()
// 		if err != nil {
// 			return nil, err
// 		}
// 		return s, nil
// 	}
// }

type FormatErrNotSupportFileType string

func (e FormatErrNotSupportFileType) Error() string {
	return fmt.Sprintf("not support file type %s", string(e))
}

func JoinFlvLive(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)

	ctx.Header("Cache-Control", "no-store")
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	movieId := strings.TrimSuffix(strings.Trim(ctx.Param("movieId"), "/"), ".flv")
	m, err := room.GetMovieByID(movieId)
	if err != nil {
		log.Errorf("join flv live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	if !m.Movie.MovieBase.Live {
		log.Error("join hls live error: live is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live is not enabled"))
		return
	}
	if m.Movie.MovieBase.RtmpSource {
		if !conf.Conf.Server.Rtmp.Enable {
			log.Error("join hls live error: rtmp is not enabled")
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("rtmp is not enabled"))
			return
		}
	} else if !settings.LiveProxy.Get() {
		log.Error("join hls live error: live proxy is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live proxy is not enabled"))
		return
	}
	channel, err := m.Channel()
	if err != nil {
		log.Errorf("join flv live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}

	w := httpflv.NewHttpFLVWriter(ctx.Writer)
	defer w.Close()
	err = channel.AddPlayer(w)
	if err != nil {
		log.Errorf("join flv live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	err = w.SendPacket()
	if err != nil {
		log.Errorf("join flv live error: %v", err)
		return
	}
}

func JoinHlsLive(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)

	ctx.Header("Cache-Control", "no-store")
	room := ctx.MustGet("room").(*op.RoomEntry).Value()
	movieId := strings.TrimSuffix(strings.Trim(ctx.Param("movieId"), "/"), ".m3u8")
	m, err := room.GetMovieByID(movieId)
	if err != nil {
		log.Errorf("join hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	if !m.Movie.MovieBase.Live {
		log.Error("join hls live error: live is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live is not enabled"))
		return
	}
	if m.Movie.MovieBase.RtmpSource {
		if !conf.Conf.Server.Rtmp.Enable {
			log.Error("join hls live error: rtmp is not enabled")
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("rtmp is not enabled"))
			return
		}
	} else if !settings.LiveProxy.Get() {
		log.Error("join hls live error: live proxy is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live proxy is not enabled"))
		return
	}

	if utils.IsM3u8Url(m.Movie.MovieBase.Url) {
		_ = proxy.ProxyM3u8(ctx, m.Movie.MovieBase.Url, m.Movie.MovieBase.Headers, true, ctx.GetString("token"), room.ID, m.ID)
		return
	}
	channel, err := m.Channel()
	if err != nil {
		log.Errorf("join hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}

	b, err := channel.GenM3U8File(func(tsName string) (tsPath string) {
		ext := "ts"
		if settings.TsDisguisedAsPng.Get() {
			ext = "png"
		}
		return fmt.Sprintf("/api/room/movie/live/hls/data/%s/%s/%s.%s", room.ID, movieId, tsName, ext)
	})
	if err != nil {
		log.Errorf("join hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	ctx.Data(http.StatusOK, hls.M3U8ContentType, b)
}

func ServeHlsLive(ctx *gin.Context) {
	log := ctx.MustGet("log").(*log.Entry)
	roomId := ctx.Param("roomId")
	roomE, err := op.LoadRoomByID(roomId)
	if err != nil {
		log.Errorf("serve hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	room := roomE.Value()

	ctx.Header("Cache-Control", "public, max-age=30, s-maxage=90")

	movieId := ctx.Param("movieId")
	m, err := room.GetMovieByID(movieId)
	if err != nil {
		log.Errorf("serve hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}
	if !m.Movie.MovieBase.Live {
		log.Error("join hls live error: live is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live is not enabled"))
		return
	}
	if m.Movie.MovieBase.RtmpSource {
		if !conf.Conf.Server.Rtmp.Enable {
			log.Error("join hls live error: rtmp is not enabled")
			ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("rtmp is not enabled"))
			return
		}
	} else if !settings.LiveProxy.Get() {
		log.Error("join hls live error: live proxy is not enabled")
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorStringResp("live proxy is not enabled"))
		return
	}
	channel, err := m.Channel()
	if err != nil {
		log.Errorf("serve hls live error: %v", err)
		ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
		return
	}

	dataId := ctx.Param("dataId")
	switch fileExt := filepath.Ext(dataId); fileExt {
	case ".ts":
		if settings.TsDisguisedAsPng.Get() {
			log.Errorf("serve hls live error: %v", FormatErrNotSupportFileType(fileExt))
			ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(FormatErrNotSupportFileType(fileExt)))
			return
		}
		b, err := channel.GetTsFile(strings.TrimSuffix(dataId, fileExt))
		if err != nil {
			log.Errorf("serve hls live error: %v", err)
			ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
			return
		}
		ctx.Header("Cache-Control", "public, max-age=90")
		ctx.Data(http.StatusOK, hls.TSContentType, b)
	case ".png":
		if !settings.TsDisguisedAsPng.Get() {
			log.Errorf("serve hls live error: %v", FormatErrNotSupportFileType(fileExt))
			ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(FormatErrNotSupportFileType(fileExt)))
			return
		}
		b, err := channel.GetTsFile(strings.TrimSuffix(dataId, fileExt))
		if err != nil {
			log.Errorf("serve hls live error: %v", err)
			ctx.AbortWithStatusJSON(http.StatusNotFound, model.NewApiErrorResp(err))
			return
		}
		ctx.Header("Cache-Control", "public, max-age=90")
		img := image.NewGray(image.Rect(0, 0, 1, 1))
		img.Set(1, 1, color.Gray{uint8(rand.Intn(255))})
		cache := bytes.NewBuffer(make([]byte, 0, 71))
		err = png.Encode(cache, img)
		if err != nil {
			log.Errorf("serve hls live error: %v", err)
			ctx.AbortWithStatusJSON(http.StatusInternalServerError, model.NewApiErrorResp(err))
			return
		}
		ctx.Data(http.StatusOK, "image/png", append(cache.Bytes(), b...))
	default:
		ctx.Header("Cache-Control", "no-store")
		log.Errorf("serve hls live error: %v", FormatErrNotSupportFileType(fileExt))
		ctx.AbortWithStatusJSON(http.StatusBadRequest, model.NewApiErrorResp(FormatErrNotSupportFileType(fileExt)))
	}
}