utils/mkflex/logic.go

package mkflex

import (
	"cmp"
	"errors"
	"fmt"
	"os"

	conutils "codeberg.org/danjones000/utils/convids"
	"gopkg.in/yaml.v3"
)

var ErrMissingAliases = errors.New("missing aliases")
var ErrMissingShowGrp = errors.New("missing show group")

func NewConfig(path string) (*Config, error) {
	//nolint:gosec // I don't care if this is user input
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	ydec := yaml.NewDecoder(f)
	var conf Config
	err = ydec.Decode(&conf)
	if err != nil {
		return nil, err
	}

	return &conf, nil
}

func AddShows(conf *Config, data *conutils.Data) error {
	aliases, ok := conf.Templates["x-aliases"]
	reg, anime, err := getAliases(aliases, ok)

	if err != nil {
		return nil
	}

	nonEng := (*data.Shows)["non-eng"]
	aniShow := (*data.Shows)["anime"]

	dor, err := getDorama(nonEng, reg)
	if err != nil {
		return nil
	}
	conf.Templates["dorama"] = Template{Series: dor}

	aniSer, err := getAnime(aniShow, anime)
	if err != nil {
		return nil
	}
	conf.Templates["anime"] = Template{Series: aniSer}
	all, err := getAll(data, reg)
	if err != nil {
		return nil
	}
	conf.Templates["shows"] = Template{Series: all}

	return nil
}

func getAliases(aliases Template, ok bool) (reg, anime *Series, err error) {
	if !ok {
		err = ErrMissingAliases
		return
	}

	for _, alias := range aliases.Series {
		if rF, ok := alias["x-regular"]; ok {
			reg = &rF
		}
		if rA, ok := alias["x-anime"]; ok {
			anime = &rA
		}
	}

	if reg == nil {
		err = errors.Join(err, fmt.Errorf("%w: %s", ErrMissingAliases, "x-regular"))
	}

	if anime == nil {
		err = errors.Join(err, fmt.Errorf("%w: %s", ErrMissingAliases, "x-anime"))
	}

	return
}

func getShow(show conutils.Show, sh Series) SeriesGroups {
	if !show.Flexget.Begin.IsZero() {
		sh.Begin = show.Flexget.Begin
	}
	if show.Flexget.Quality != "" {
		sh.Quality = show.Flexget.Quality
	}
	sh.AlternameName = show.Flexget.AlternateName
	sh.Exact = show.Flexget.Exact
	name := cmp.Or(show.Flexget.Name, show.Name, show.Pattern)
	return SeriesGroups{name: sh}
}

func getDorama(nonEng *conutils.Shows, tmp *Series) ([]SeriesGroups, error) {
	if len(*nonEng) == 0 {
		return nil, fmt.Errorf("%w: %s", ErrMissingShowGrp, "non-eng")
	}
	grp := make([]SeriesGroups, 0, len(*nonEng))

	for _, show := range *nonEng {
		if !show.Flexget.Skip {
			grp = append(grp, getShow(*show, *tmp))
		}
	}

	return grp, nil
}

func getAnime(anime *conutils.Shows, tmp *Series) ([]SeriesGroups, error) {
	grp := make([]SeriesGroups, 0, len(*anime))

	for _, show := range *anime {
		if !show.Flexget.Skip {
			grp = append(grp, getShow(*show, *tmp))
		}
	}

	return grp, nil
}

func getAll(data *conutils.Data, tmp *Series) ([]SeriesGroups, error) {
	grp := make([]SeriesGroups, 0, 100)

	for _, group := range data.Config.Groups {
		shGrp, ok := (*data.Shows)[group]
		if group == "old" || shGrp == nil || !ok {
			continue
		}
		for _, show := range *shGrp {
			if !show.Flexget.Skip && !show.Anime {
				grp = append(grp, getShow(*show, *tmp))
			}
		}
	}

	return grp, nil
}