Mining/pkg/mining/miner_factory.go

package mining

import (
	"sync"
	"unicode"
)

// toLowerASCII("XMRig") == "xmrig"
// toLowerASCII("TT-Miner") == "tt-miner"
func toLowerASCII(input string) string {
	runes := []rune(input)
	for i, character := range runes {
		runes[i] = unicode.ToLower(character)
	}
	return string(runes)
}

// f.Register("custom", func() Miner { return NewCustomMiner() })
type MinerConstructor func() Miner

// factory := NewMinerFactory()
// factory.Register("xmrig", func() Miner { return NewXMRigMiner() })
type MinerFactory struct {
	mutex        sync.RWMutex
	constructors map[string]MinerConstructor
	aliases      map[string]string // maps aliases to canonical names
}

// globalFactory := NewMinerFactory()
// miner, err := globalFactory.Create("xmrig")
var globalFactory = NewMinerFactory()

// factory := NewMinerFactory()
// factory.Register("xmrig", func() Miner { return NewXMRigMiner() })
func NewMinerFactory() *MinerFactory {
	factory := &MinerFactory{
		constructors: make(map[string]MinerConstructor),
		aliases:      make(map[string]string),
	}
	factory.registerDefaults()
	return factory
}

// factory.registerDefaults() // called in NewMinerFactory(); adds xmrig, tt-miner, simulated to constructors
func (factory *MinerFactory) registerDefaults() {
	// XMRig miner (CPU/GPU RandomX, Cryptonight, etc.)
	factory.Register("xmrig", func() Miner { return NewXMRigMiner() })

	// TT-Miner (GPU Kawpow, etc.)
	factory.Register("tt-miner", func() Miner { return NewTTMiner() })
	factory.RegisterAlias("ttminer", "tt-miner")

	// Simulated miner for testing and development
	factory.Register(MinerTypeSimulated, func() Miner {
		return NewSimulatedMiner(SimulatedMinerConfig{
			Name:         "simulated-miner",
			Algorithm:    "rx/0",
			BaseHashrate: 1000,
			Variance:     0.1,
		})
	})
}

// factory.Register("xmrig", func() Miner { return NewXMRigMiner() })
func (factory *MinerFactory) Register(name string, constructor MinerConstructor) {
	factory.mutex.Lock()
	defer factory.mutex.Unlock()
	factory.constructors[toLowerASCII(name)] = constructor
}

// factory.RegisterAlias("ttminer", "tt-miner")
func (factory *MinerFactory) RegisterAlias(alias, canonicalName string) {
	factory.mutex.Lock()
	defer factory.mutex.Unlock()
	factory.aliases[toLowerASCII(alias)] = toLowerASCII(canonicalName)
}

// miner, err := factory.Create("xmrig")
func (factory *MinerFactory) Create(minerType string) (Miner, error) {
	factory.mutex.RLock()
	defer factory.mutex.RUnlock()

	name := toLowerASCII(minerType)

	// Check for alias first
	if canonical, ok := factory.aliases[name]; ok {
		name = canonical
	}

	constructor, ok := factory.constructors[name]
	if !ok {
		return nil, ErrUnsupportedMiner(minerType)
	}

	return constructor(), nil
}

// if factory.IsSupported("tt-miner") { ... }
func (factory *MinerFactory) IsSupported(minerType string) bool {
	factory.mutex.RLock()
	defer factory.mutex.RUnlock()

	name := toLowerASCII(minerType)

	// Check alias
	if canonical, ok := factory.aliases[name]; ok {
		name = canonical
	}

	_, ok := factory.constructors[name]
	return ok
}

// types := factory.ListTypes() // ["xmrig", "tt-miner", "simulated"]
func (factory *MinerFactory) ListTypes() []string {
	factory.mutex.RLock()
	defer factory.mutex.RUnlock()

	types := make([]string, 0, len(factory.constructors))
	for name := range factory.constructors {
		types = append(types, name)
	}
	return types
}

// --- Global factory functions for convenience ---

// miner, err := CreateMiner("xmrig")
func CreateMiner(minerType string) (Miner, error) {
	return globalFactory.Create(minerType)
}

// if IsMinerSupported("tt-miner") { ... }
func IsMinerSupported(minerType string) bool {
	return globalFactory.IsSupported(minerType)
}

// types := ListMinerTypes() // ["xmrig", "tt-miner", "simulated"]
func ListMinerTypes() []string {
	return globalFactory.ListTypes()
}

// RegisterMinerType("custom", func() Miner { return NewCustomMiner() })
func RegisterMinerType(name string, constructor MinerConstructor) {
	globalFactory.Register(name, constructor)
}

// RegisterMinerAlias("ttminer", "tt-miner")
func RegisterMinerAlias(alias, canonicalName string) {
	globalFactory.RegisterAlias(alias, canonicalName)
}