package convertor

import (
	"bufio"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/application/convertor/encoder"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/ffmpeg"
	"io"
	"os/exec"
	"strings"
)

type ConvertorContract interface {
	RunConvert(setting ffmpeg.ConvertSetting, progress ffmpeg.ProgressContract) error
	GetSupportFormats() (encoder.ConvertorFormatsContract, error)
	GetRunningProcesses() map[int]*exec.Cmd
}

type runningProcesses struct {
	items          map[int]*exec.Cmd
	numberOfStarts int
}

type convertor struct {
	ffmpegService    ffmpeg.UtilitiesContract
	runningProcesses *runningProcesses
}

func NewConvertor(
	ffmpegService ffmpeg.UtilitiesContract,
) ConvertorContract {
	return &convertor{
		ffmpegService:    ffmpegService,
		runningProcesses: &runningProcesses{items: map[int]*exec.Cmd{}, numberOfStarts: 0},
	}
}

func (c *convertor) RunConvert(setting ffmpeg.ConvertSetting, progress ffmpeg.ProgressContract) error {
	ffmpegService, err := c.ffmpegService.GetFFmpeg()
	if err != nil {
		return err
	}

	index := c.runningProcesses.numberOfStarts
	beforeWait := func(cmd *exec.Cmd) {
		c.runningProcesses.numberOfStarts++
		c.runningProcesses.items[index] = cmd
	}

	afterWait := func(cmd *exec.Cmd) {
		delete(c.runningProcesses.items, index)
	}

	return ffmpegService.RunConvert(setting, progress, beforeWait, afterWait)
}

func (c *convertor) GetSupportFormats() (encoder.ConvertorFormatsContract, error) {
	var err error

	formats := encoder.NewConvertorFormats()
	ffmpeg, err := c.ffmpegService.GetFFmpeg()
	if err != nil {
		return formats, err
	}
	err = ffmpeg.GetEncoders(func(scanner *bufio.Reader) {
		for {
			line, _, err := scanner.ReadLine()
			if err != nil {
				if err == io.EOF {
					break
				}
				continue
			}
			text := strings.Split(strings.TrimSpace(string(line)), " ")
			encoderType := string(text[0][0])
			if len(text) < 2 || (encoderType != "V" && encoderType != "A") {
				continue
			}
			formats.NewEncoder(text[1])
		}
	})

	return formats, err
}

func (c *convertor) GetRunningProcesses() map[int]*exec.Cmd {
	return c.runningProcesses.items
}