package jobs

import (
	"context"
	"time"

	"backend/app/http/medias"
	"backend/app/http/posts"
	"backend/app/http/storages"
	"backend/database/fields"
	"backend/database/models/qvyun_v2/public/model"

	_ "git.ipao.vip/rogeecn/atom"
	_ "git.ipao.vip/rogeecn/atom/contracts"
	"github.com/pkg/errors"
	. "github.com/riverqueue/river"
	"github.com/samber/lo"
	"github.com/sirupsen/logrus"
)

var (
	_ JobArgs               = (*PostDeleteAssetsJob)(nil)
	_ JobArgsWithInsertOpts = (*PostDeleteAssetsJob)(nil)
)

type PostDeleteAssetsJob struct {
	PostID int64
}

// InsertOpts implements JobArgsWithInsertOpts.
func (s PostDeleteAssetsJob) InsertOpts() InsertOpts {
	return InsertOpts{
		Queue:    QueueDefault,
		Priority: PriorityDefault,
		UniqueOpts: UniqueOpts{
			ByArgs: true,
		},
	}
}

func (PostDeleteAssetsJob) Kind() string {
	return "PostDeleteAssetsJob"
}

var _ Worker[PostDeleteAssetsJob] = (*PostDeleteAssetsJobWorker)(nil)

// @provider(job)
type PostDeleteAssetsJobWorker struct {
	WorkerDefaults[PostDeleteAssetsJob]

	log *logrus.Entry `inject:"false"`

	postSvc    *posts.Service
	mediaSvc   *medias.Service
	storageSvc *storages.Service
}

func (w *PostDeleteAssetsJobWorker) Prepare() error {
	w.log = logrus.WithField("worker", "PostDeleteAssetsJobWorker")
	return nil
}

func (w *PostDeleteAssetsJobWorker) NextRetry(job *Job[PostDeleteAssetsJob]) time.Time {
	return time.Now().Add(5 * time.Second)
}

func (w *PostDeleteAssetsJobWorker) Work(ctx context.Context, job *Job[PostDeleteAssetsJob]) error {
	post, err := w.postSvc.ForceGetPostByID(ctx, job.Args.PostID)
	if err != nil {
		return errors.Wrapf(err, "failed to get post(%d) by id", job.Args.PostID)
	}

	mediaIDs := lo.Map(post.Assets.Data, func(asset fields.MediaAsset, _ int) int64 {
		return asset.Media
	})

	medias, err := w.mediaSvc.GetMediasByIDs(ctx, post.TenantID, post.UserID, mediaIDs)
	if err != nil {
		return errors.Wrapf(err, "failed to get medias by ids(%v)", mediaIDs)
	}

	storageIds := lo.Map(medias, func(media *model.Medias, _ int) int64 { return media.StorageID })
	storageMap, err := w.storageSvc.GetFSMapByIDs(ctx, storageIds...)
	if err != nil {
		return err
	}

	// remove assets
	for _, media := range medias {
		st, ok := storageMap[media.StorageID]
		if !ok {
			continue
		}

		if err := st.Remove(media.Path); err != nil {
			return errors.Wrapf(err, "failed to remove media(%d)", media.ID)
		}
	}

	// delete all assets
	ids := lo.Map(medias, func(media *model.Medias, _ int) int64 { return media.ID })
	if err := w.mediaSvc.DeleteByID(ctx, ids...); err != nil {
		return errors.Wrapf(err, "failed to delete media(%d)", ids)
	}

	return nil
}