package ffmpeg

import (
	"errors"
	"fyne.io/fyne/v2/lang"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/application/setting"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/internal/ffmpeg/encoder"
)

type File struct {
	Path string
	Name string
	Ext  string
}

type ConvertSetting struct {
	FileInput            File
	FileOut              File
	OverwriteOutputFiles bool
	Encoder              encoder.EncoderContract
}

type UtilitiesContract interface {
	UtilityCheck() bool

	GetFFmpeg() (FFmpegContract, error)
	GetFFmpegVersion() string
	GetFFmpegPath() string
	ChangeFFmpeg(path string) error

	GetFFprobe() (FFprobeContract, error)
	GetFFprobeVersion() string
	GetFFprobePath() string
	ChangeFFprobe(path string) error

	GetFFplay() (FFplayContract, error)
	GetFFplayPath() string
	ChangeFFplay(path string) error
}

type utilities struct {
	setting setting.SettingContract
	ffmpeg  FFmpegContract
	ffprobe FFprobeContract
	ffplay  FFplayContract
}

func NewUtilities(setting setting.SettingContract) UtilitiesContract {
	return &utilities{
		setting: setting,
	}
}

func (u *utilities) UtilityCheck() bool {
	var err error

	_, err = u.GetFFmpeg()
	if err != nil {
		return false
	}

	_, err = u.GetFFprobe()
	if err != nil {
		return false
	}

	_, err = u.GetFFplay()
	if err != nil {
		return false
	}

	return true
}

func (u *utilities) GetFFmpeg() (FFmpegContract, error) {
	if u.ffmpeg == nil {
		createFFmpeg, err := newFFmpeg(u.setting.GetFFmpegPath())
		if err != nil {
			return nil, err
		}
		u.ffmpeg = createFFmpeg
	}

	return u.ffmpeg, nil
}

func (u *utilities) GetFFmpegVersion() string {
	ffmpegService, err := u.GetFFmpeg()
	if err != nil {
		return lang.L("errorFFmpegVersion")
	}

	version, err := ffmpegService.GetVersion()
	if err != nil {
		return lang.L("errorFFmpegVersion")
	}
	return version
}

func (u *utilities) GetFFmpegPath() string {
	ffmpegService, err := u.GetFFmpeg()
	if err != nil {
		return ""
	}
	return ffmpegService.GetPath()
}

func (u *utilities) ChangeFFmpeg(path string) error {
	if path == "" {
		return errors.New(lang.L("errorFFmpeg"))
	}

	createFFmpeg, err := newFFmpeg(path)
	if err != nil {
		return err
	}

	u.ffmpeg = createFFmpeg
	u.setting.SetFFmpegPath(path)

	return nil
}

func (u *utilities) GetFFprobe() (FFprobeContract, error) {
	if u.ffprobe == nil {
		createFFprobe, err := newFFprobe(u.setting.GetFFprobePath())
		if err != nil {
			return nil, err
		}
		u.ffprobe = createFFprobe
	}

	return u.ffprobe, nil
}

func (u *utilities) GetFFprobeVersion() string {
	ffprobeService, err := u.GetFFprobe()
	if err != nil {
		return lang.L("errorFFprobeVersion")
	}

	ffprobeVersion, err := ffprobeService.GetVersion()
	if err != nil {
		return lang.L("errorFFprobeVersion")
	}
	return ffprobeVersion
}

func (u *utilities) GetFFprobePath() string {
	ffprobeService, err := u.GetFFprobe()
	if err != nil {
		return ""
	}
	return ffprobeService.GetPath()
}

func (u *utilities) ChangeFFprobe(path string) error {
	if path == "" {
		return errors.New(lang.L("errorFFprobe"))
	}

	createFFprobe, err := newFFprobe(path)
	if err != nil {
		return err
	}

	u.ffprobe = createFFprobe
	u.setting.SetFFprobePath(path)

	return nil
}

func (u *utilities) GetFFplay() (FFplayContract, error) {
	if u.ffplay == nil {
		createFFplay, err := newFFplay(u.setting.GetFFplayPath())
		if err != nil {
			return nil, err
		}
		u.ffplay = createFFplay
	}

	return u.ffplay, nil
}

func (u *utilities) GetFFplayPath() string {
	ffplayService, err := u.GetFFplay()
	if err != nil {
		return ""
	}
	return ffplayService.GetPath()
}

func (u *utilities) ChangeFFplay(path string) error {
	if path == "" {
		return errors.New(lang.L("errorFFplay"))
	}

	createFFplay, err := newFFplay(path)
	if err != nil {
		return err
	}

	u.ffplay = createFFplay
	u.setting.SetFFplayPath(path)

	return nil
}