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)
	GetFFplayVersion() string
	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) GetFFplayVersion() string {
	ffplayService, err := u.GetFFplay()
	if err != nil {
		return lang.L("errorFFplayVersion")
	}

	ffplayVersion, err := ffplayService.GetVersion()
	if err != nil {
		return lang.L("errorFFplayVersion")
	}
	return ffplayVersion
}

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
}