package jobs

import (
	"context"
	"os"
	"path/filepath"
	"time"

	"quyun/app/models"
	"quyun/database/fields"
	"quyun/database/schemas/public/model"
	"quyun/pkg/utils"
	"quyun/providers/ali"
	"quyun/providers/app"
	"quyun/providers/job"

	. "github.com/riverqueue/river"
	log "github.com/sirupsen/logrus"
	_ "go.ipao.vip/atom"
	"go.ipao.vip/atom/contracts"
)

var _ contracts.JobArgs = (*VideoExtractHeadImage)(nil)

type VideoExtractHeadImage struct {
	MediaID int64 `json:"media_id"`
}

func (s VideoExtractHeadImage) InsertOpts() InsertOpts {
	return InsertOpts{
		Queue:    QueueDefault,
		Priority: PriorityDefault,
	}
}

func (s VideoExtractHeadImage) Kind() string     { return "video_extract_head_image" }
func (a VideoExtractHeadImage) UniqueID() string { return a.Kind() }

var _ Worker[VideoExtractHeadImage] = (*VideoExtractHeadImageWorker)(nil)

// @provider(job)
type VideoExtractHeadImageWorker struct {
	WorkerDefaults[VideoExtractHeadImage]

	oss *ali.OSSClient
	job *job.Job
	app *app.Config
}

func (w *VideoExtractHeadImageWorker) NextRetry(job *Job[VideoExtractHeadImage]) time.Time {
	return time.Now().Add(30 * time.Second)
}

func (w *VideoExtractHeadImageWorker) Work(ctx context.Context, job *Job[VideoExtractHeadImage]) error {
	log := log.WithField("job", job.Args.Kind())

	log.Infof("[Start] Working on job with strings: %+v", job.Args)
	defer log.Infof("[End] Finished %s", job.Args.Kind())

	media, err := models.Medias.GetByID(ctx, job.Args.MediaID)
	if err != nil {
		log.Errorf("Error getting media by ID: %v", err)
		return JobCancel(err)
	}
	_ = media

	input := filepath.Join(w.app.StoragePath, media.Path)
	output := input[:len(input)-len(filepath.Ext(input))] + ".jpg"

	if err := utils.GetFrameImageFromVideo(input, output, 1); err != nil {
		log.Errorf("Error extracting image from video: %v", err)
		return JobCancel(err)
	}
	defer os.RemoveAll(output)

	// Upload the image to OSS
	if err := w.oss.Upload(ctx, output, filepath.Base(output)); err != nil {
		log.Errorf("Error uploading image to OSS: %v", err)
		return JobCancel(err)
	}

	fileSize, err := utils.GetFileSize(output)
	if err != nil {
		log.Errorf("Error getting file size: %v", err)
		return JobCancel(err)
	}

	fileMd5, err := utils.GetFileMd5(output)
	if err != nil {
		log.Errorf("Error getting file MD5: %v", err)
		return JobCancel(err)
	}

	// create a new media record for the image
	imageMedia := &model.Medias{
		CreatedAt: time.Now(),
		Name:      "[展示图]" + media.Name,
		MimeType:  "image/jpeg",
		Size:      fileSize,
		Path:      w.oss.GetSavePath(filepath.Base(output)),
		Hash:      fileMd5,
		Metas:     fields.Json[fields.MediaMetas]{},
	}

	if err := models.Medias.Create(ctx, imageMedia); err != nil {
		log.Errorf("Error creating media record: %v", err)
		return JobCancel(err)
	}

	return nil
}