gui-for-ffmpeg/internal/application/convertor/queue.go

package convertor

import (
	"errors"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/ffmpeg"
)

type Queue struct {
	Setting *ffmpeg.ConvertSetting
	Status  StatusContract
	Error   error
}

type StatusContract interface {
	Name() string
	Ordinal() int
}

const (
	Waiting = iota
	InProgress
	Completed
	Error
)

type StatusType uint

var statusTypeStrings = []string{
	"waiting",
	"inProgress",
	"completed",
	"error",
}

func (status StatusType) Name() string {
	return statusTypeStrings[status]
}

func (status StatusType) Ordinal() int {
	return int(status)
}

type QueueListenerContract interface {
	AddQueue(key int, queue *Queue)
	ChangeQueue(key int, queue *Queue)
	RemoveQueue(key int, status StatusContract)
}

type QueueListContract interface {
	AddListener(queueListener QueueListenerContract)
	GetItems() map[int]*Queue
	Add(setting *ffmpeg.ConvertSetting)
	EventChangeQueue(key int, queue *Queue)
	Remove(key int)
	GetItem(key int) (*Queue, error)
	Next() (key int, queue *Queue)
}

type queueList struct {
	currentKey    int
	items         map[int]*Queue
	queue         map[int]int
	queueListener map[int]QueueListenerContract
}

func NewQueueList() QueueListContract {
	return &queueList{
		currentKey:    0,
		items:         map[int]*Queue{},
		queueListener: map[int]QueueListenerContract{},
	}
}

func (l *queueList) GetItems() map[int]*Queue {
	return l.items
}

func (l *queueList) Add(setting *ffmpeg.ConvertSetting) {
	queue := Queue{
		Setting: setting,
		Status:  StatusType(Waiting),
	}

	l.currentKey += 1
	l.items[l.currentKey] = &queue
	l.queue[l.currentKey] = l.currentKey

	l.eventAdd(l.currentKey, &queue)
}

func (l *queueList) EventChangeQueue(key int, queue *Queue) {
	l.eventChange(key, queue)
}

func (l *queueList) Remove(key int) {
	if _, ok := l.queue[key]; ok {
		delete(l.queue, key)
	}

	if _, ok := l.items[key]; ok {
		status := l.items[key].Status
		l.eventRemove(key, status)
		delete(l.items, key)
	}
}

func (l *queueList) GetItem(key int) (*Queue, error) {
	if item, ok := l.items[key]; ok {
		return item, nil
	}

	return nil, errors.New("key not found")
}

func (l *queueList) AddListener(queueListener QueueListenerContract) {
	l.queueListener[len(l.queueListener)] = queueListener
}

func (l *queueList) Next() (key int, queue *Queue) {
	statusWaiting := StatusType(Waiting)
	for key, queueId := range l.queue {
		if queue, ok := l.items[queueId]; ok {
			if queue.Status == statusWaiting {
				return queueId, queue
			}
		}

		if _, ok := l.queue[key]; ok {
			delete(l.queue, key)
		}
	}
	return -1, nil
}

func (l *queueList) eventAdd(key int, queue *Queue) {
	for _, listener := range l.queueListener {
		listener.AddQueue(key, queue)
	}
}

func (l *queueList) eventChange(key int, queue *Queue) {
	for _, listener := range l.queueListener {
		listener.ChangeQueue(key, queue)
	}
}

func (l *queueList) eventRemove(key int, status StatusContract) {
	for _, listener := range l.queueListener {
		listener.RemoveQueue(key, status)
	}
}