path: root/internal/action/recipe.go

package action

import (
	"fmt"
	"os"
	"path/filepath"

	"gopkg.in/yaml.v3"
)

type ConsumeEntry struct {
	Items      []string `yaml:"items"`
	Quantity   int      `yaml:"quantity"`
	Byproducts []string `yaml:"byproducts"`
}

type RecipeDef struct {
	ID          string          `yaml:"id"`
	Type        string          `yaml:"type"`
	Skill       string          `yaml:"skill"`
	Level       int             `yaml:"level"`
	XP          int             `yaml:"xp"`
	Station     []string        `yaml:"station"`
	Tool        string          `yaml:"tool"`
	Consume     []ConsumeEntry  `yaml:"consume"`
	Output      string          `yaml:"output"`
	OutputQty   int             `yaml:"output_qty"`
	Fail        string          `yaml:"fail"`
	Message     string          `yaml:"message"`
	FailMessage string          `yaml:"fail_message"`
	Wait        float64         `yaml:"wait"`
	Success     *SuccessFormula `yaml:"success"`
}

type consolidatedRecipeDef struct {
	Type     string          `yaml:"type"`
	Skill    string          `yaml:"skill"`
	Station  []string        `yaml:"station"`
	Tool     string          `yaml:"tool"`
	Wait     float64         `yaml:"wait"`
	Consume  []ConsumeEntry  `yaml:"consume"`
	Products []recipeProduct `yaml:"products"`
}

type recipeProduct struct {
	ID          string          `yaml:"id"`
	Output      string          `yaml:"output"`
	OutputQty   int             `yaml:"output_qty"`
	Level       int             `yaml:"level"`
	XP          int             `yaml:"xp"`
	Consume     []ConsumeEntry  `yaml:"consume"`
	Message     string          `yaml:"message"`
	FailMessage string          `yaml:"fail_message"`
	Fail        string          `yaml:"fail"`
	Success     *SuccessFormula `yaml:"success"`
}

type RecipeStore struct {
	dataDir string
	cache   map[string][]RecipeDef
	byID    map[string]*RecipeDef
}

func NewRecipeStore(dataDir string) *RecipeStore {
	return &RecipeStore{
		dataDir: dataDir,
		cache:   make(map[string][]RecipeDef),
		byID:    make(map[string]*RecipeDef),
	}
}

func (s *RecipeStore) GetByID(recipeID string) *RecipeDef {
	if r, ok := s.byID[recipeID]; ok {
		return r
	}
	s.ensureLoaded()
	if r, ok := s.byID[recipeID]; ok {
		return r
	}
	return nil
}

func (s *RecipeStore) ensureLoaded() {
	if _, ok := s.cache["_all"]; ok {
		return
	}
	all, err := s.loadAllRaw()
	if err != nil {
		return
	}
	s.cache["_all"] = all
	for i := range all {
		if all[i].ID != "" {
			s.byID[all[i].ID] = &all[i]
		}
	}
}

func (s *RecipeStore) LoadAll() ([]RecipeDef, error) {
	return s.LoadByType("")
}

func (s *RecipeStore) LoadByType(recipeType string) ([]RecipeDef, error) {
	if recipeType == "" {
		recipeType = "_all"
	}
	if cached, ok := s.cache[recipeType]; ok {
		result := make([]RecipeDef, len(cached))
		copy(result, cached)
		return result, nil
	}

	s.ensureLoaded()
	all := s.cache["_all"]

	if recipeType == "_all" {
		result := make([]RecipeDef, len(all))
		copy(result, all)
		return result, nil
	}

	var filtered []RecipeDef
	for _, r := range all {
		if r.Type == recipeType {
			filtered = append(filtered, r)
		}
	}
	s.cache[recipeType] = filtered
	result := make([]RecipeDef, len(filtered))
	copy(result, filtered)
	return result, nil
}

func (s *RecipeStore) loadAllRaw() ([]RecipeDef, error) {
	dir := filepath.Join(s.dataDir, "recipes")
	var recipes []RecipeDef
	WalkYAMLDir(dir, func(path, id string, data []byte) error {
		var r RecipeDef
		if err := yaml.Unmarshal(data, &r); err == nil && r.Type != "" {
			recipes = append(recipes, r)
			return nil
		}

		var cr consolidatedRecipeDef
		if err := yaml.Unmarshal(data, &cr); err != nil {
			fmt.Fprintf(os.Stderr, "recipe parse error %s: %v\n", path, err)
			return nil
		}
		if cr.Type == "" || len(cr.Products) == 0 {
			return nil
		}

		for _, p := range cr.Products {
			recipes = append(recipes, s.expandProduct(cr, p))
		}
		return nil
	})
	return recipes, nil
}

func (s *RecipeStore) expandProduct(cr consolidatedRecipeDef, p recipeProduct) RecipeDef {
	r := RecipeDef{
		ID:          p.ID,
		Output:      p.Output,
		OutputQty:   p.OutputQty,
		Type:        cr.Type,
		Skill:       cr.Skill,
		Level:       p.Level,
		XP:          p.XP,
		Station:     cr.Station,
		Tool:        cr.Tool,
		Wait:        cr.Wait,
		Consume:     p.Consume,
		Message:     p.Message,
		FailMessage: p.FailMessage,
		Fail:        p.Fail,
		Success:     p.Success,
	}
	if len(r.Consume) == 0 {
		r.Consume = cr.Consume
	}
	return r
}

func (r *RecipeDef) MatchesEntry(itemID string) bool {
	for _, e := range r.Consume {
		for _, id := range e.Items {
			if id == itemID {
				return true
			}
		}
	}
	return false
}

func (s *RecipeStore) FindByInput(recipeType string, itemID string) *RecipeDef {
	all, err := s.LoadByType(recipeType)
	if err != nil {
		return nil
	}
	for i := range all {
		for _, e := range all[i].Consume {
			for _, id := range e.Items {
				if id == itemID {
					return &all[i]
				}
			}
		}
	}
	return nil
}


func (s *RecipeStore) FindByStation(itemID string, stationIDs []string, recipeType string) ([]RecipeDef, error) {
	all, err := s.LoadByType(recipeType)
	if err != nil {
		return nil, err
	}
	var matches []RecipeDef
	for _, r := range all {
		if recipeType != "" && r.Type != recipeType {
			continue
		}
		if !r.MatchesEntry(itemID) {
			continue
		}
		if len(r.Station) == 0 {
			continue
		}
		for _, station := range stationIDs {
			for _, rs := range r.Station {
				if rs == station {
					matches = append(matches, r)
					goto next
				}
			}
		}
	next:
	}
	return matches, nil
}

func (r *RecipeDef) DisplayName() string {
	return r.Output
}

func (r *RecipeDef) EffectiveSkill() string {
	if r.Skill != "" {
		return r.Skill
	}
	return r.Type
}



func (r *RecipeDef) FirstItemName(load func(string) (string, bool)) string {
	for _, e := range r.Consume {
		for _, id := range e.Items {
			if name, ok := load(id); ok {
				return name
			}
			return id
		}
	}
	return ""
}

func (r *RecipeDef) ConsumeAll(hasItem func(string) bool, removeItem func(string, int) bool) bool {
	for _, e := range r.Consume {
		found := false
		for _, id := range e.Items {
			if hasItem(id) {
				removeItem(id, e.Quantity)
			found = true
			break
		}
	}
	if !found {
		return false
	}
}
return true
}

func (r *RecipeDef) HasAllItemsQty(countItem func(string) int) bool {
	for _, e := range r.Consume {
		found := false
		for _, id := range e.Items {
			qty := e.Quantity
			if qty <= 0 {
				qty = 1
			}
			if countItem(id) >= qty {
				found = true
				break
			}
		}
		if !found {
			return false
		}
	}
	return true
}

func (r *RecipeDef) HasAllItems(hasItem func(string) bool) bool {
	for _, e := range r.Consume {
		found := false
		for _, id := range e.Items {
			if hasItem(id) {
				found = true
				break
			}
		}
		if !found {
			return false
		}
	}
	return true
}