Mining/pkg/mining/miner_factory.go

package mining

import (
	"strings"
	"sync"
)

// 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 is the default factory instance
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
}

// registerDefaults registers all built-in miners
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[strings.ToLower(name)] = constructor
}

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

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

	name := strings.ToLower(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 := strings.ToLower(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)
}