gui-for-ffmpeg/main.go

package main

import (
	"errors"
	"fyne.io/fyne/v2"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/convertor"
	dberror "git.kor-elf.net/kor-elf/gui-for-ffmpeg/db"
	error2 "git.kor-elf.net/kor-elf/gui-for-ffmpeg/error"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/handler"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/kernel"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/localizer"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/menu"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/migration"
	"git.kor-elf.net/kor-elf/gui-for-ffmpeg/setting"
	"go.etcd.io/bbolt"
	"golang.org/x/text/language"
	"os"
	"time"
)

var application kernel.AppContract
var ffPathUtilities *kernel.FFPathUtilities

func init() {
	iconResource, _ := fyne.LoadResourceFromPath("icon.png")
	appMetadata := &fyne.AppMetadata{
		ID:      "net.kor-elf.projects.gui-for-ffmpeg",
		Name:    "GUI for FFmpeg",
		Version: "0.8.0",
		Icon:    iconResource,
	}

	localizerService, err := kernel.NewLocalizer("languages", language.Russian)
	if err != nil {
		kernel.PanicErrorLang(err, appMetadata)
		return
	}

	ffPathUtilities = &kernel.FFPathUtilities{FFmpeg: "", FFprobe: "", FFplay: ""}
	convertorService := kernel.NewService(ffPathUtilities)
	ffplayService := kernel.NewFFplay(ffPathUtilities)

	queue := kernel.NewQueueList()
	application = kernel.NewApp(
		appMetadata,
		localizerService,
		queue,
		kernel.NewQueueLayoutObject(queue, localizerService, ffplayService),
		convertorService,
	)
}

func main() {
	errorView := error2.NewView(application)
	if canCreateFile("data/database.db") != true {
		errorView.PanicErrorWriteDirectoryData()
		application.GetWindow().ShowAndRun()
		return
	}

	db, err := bbolt.Open("data/database.db", 0600, &bbolt.Options{Timeout: 3 * time.Second})
	if err != nil {
		errorView.PanicError(err)
		application.GetWindow().ShowAndRun()
		return
	}

	defer db.Close()

	err = migration.Run(db)
	if err != nil {
		errorView.PanicError(err)
		application.GetWindow().ShowAndRun()
		return
	}

	settingRepository := setting.NewRepository(db)
	settingDirectoryForSaving := setting.NewSettingDirectoryForSaving(settingRepository)

	convertorRepository := convertor.NewRepository(settingRepository)
	pathFFmpeg, err := convertorRepository.GetPathFfmpeg()
	if err != nil && errors.Is(err, dberror.ErrRecordNotFound) == false {
		errorView.PanicError(err)
		application.GetWindow().ShowAndRun()
		return
	}
	ffPathUtilities.FFmpeg = pathFFmpeg

	pathFFprobe, err := convertorRepository.GetPathFfprobe()
	if err != nil && errors.Is(err, dberror.ErrRecordNotFound) == false {
		errorView.PanicError(err)
		application.GetWindow().ShowAndRun()
		return
	}
	ffPathUtilities.FFprobe = pathFFprobe

	pathFFplay, err := convertorRepository.GetPathFfplay()
	if err != nil && errors.Is(err, dberror.ErrRecordNotFound) == false {
		errorView.PanicError(err)
		application.GetWindow().ShowAndRun()
		return
	}
	ffPathUtilities.FFplay = pathFFplay

	application.RunConvertor()
	defer application.AfterClosing()

	localizerView := localizer.NewView(application)
	convertorView := convertor.NewView(application)
	convertorHandler := handler.NewConvertorHandler(application, convertorView, errorView, convertorRepository, settingDirectoryForSaving)

	localizerRepository := localizer.NewRepository(settingRepository)
	menuView := menu.NewView(application)
	mainMenu := handler.NewMenuHandler(application, convertorHandler, menuView, localizerView, localizerRepository)

	mainHandler := handler.NewMainHandler(application, convertorHandler, mainMenu, localizerRepository)
	mainHandler.Start()

	application.GetWindow().SetMainMenu(mainMenu.GetMainMenu())
	application.GetWindow().ShowAndRun()
}

func canCreateFile(path string) bool {
	file, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY, 0666)
	if err != nil {
		return false
	}
	_ = file.Close()
	return true
}