package jobs

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

	"quyun/app/models"
	"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"
	"golang.org/x/sync/errgroup"
)

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

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

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

func (s VideoCut) Kind() string     { return "video_cut" }
func (a VideoCut) UniqueID() string { return a.Kind() }

var _ Worker[VideoCut] = (*VideoCutWorker)(nil)

// @provider(job)
type VideoCutWorker struct {
	WorkerDefaults[VideoCut]

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

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

func (w *VideoCutWorker) Work(ctx context.Context, job *Job[VideoCut]) 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)
	}

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

	log.Infof("cut video process %s to %s", input, output)
	cmd := exec.Command("ffmpeg", "-ss", "00:00:00", "-i", input, "-to", "00:01:00", "-c", "copy", output)

	stdout, err := cmd.StdoutPipe()
	if err != nil {
		log.Errorf("Error creating stdout pipe: %v", err)
		return err
	}

	stderr, err := cmd.StderrPipe()
	if err != nil {
		log.Errorf("Error creating stderr pipe: %v", err)
		return err
	}

	if err := cmd.Start(); err != nil {
		log.Errorf("Error starting command: %v", err)
		return err
	}

	var eg errgroup.Group
	eg.Go(func() error {
		scanner := bufio.NewScanner(stdout)
		for scanner.Scan() {
			log.Info(scanner.Text())
		}
		return nil
	})

	eg.Go(func() error {
		scanner := bufio.NewScanner(stderr)
		for scanner.Scan() {
			log.Error(scanner.Text())
		}
		return nil
	})

	if err := cmd.Wait(); err != nil {
		log.Errorf("Error waiting for command: %v", err)
		return err
	}

	if err := eg.Wait(); err != nil {
		log.Errorf("Error waiting for command: %v", err)
		return err
	}
	return nil
}