//go:build darwin

package engine

import (
	"fmt"
	"voicesnap/internal/logger"
	"voicesnap/internal/model"

	_ "github.com/k2-fsa/sherpa-onnx-go-macos"
	sherpa "github.com/k2-fsa/sherpa-onnx-go/sherpa_onnx"
)

type sherpaEngine struct {
	recognizer *sherpa.OfflineRecognizer
	hwInfo     string
}

func newPlatformEngine(resolved model.ResolvedModel) (Engine, error) {
	if !isSupportedBackend(resolved.BackendKind) {
		return nil, fmt.Errorf("unsupported backend kind: %s", resolved.BackendKind)
	}

	providers := darwinProviders(resolved.ProviderOrder)

	for _, p := range providers {
		config, err := offlineConfigForResolvedModel(resolved, p.provider)
		if err != nil {
			return nil, err
		}

		recognizer := sherpa.NewOfflineRecognizer(&config)
		if recognizer != nil {
			info := fmt.Sprintf("%s · %s", resolved.Profile.DisplayName, p.name)
			logger.Info("Engine initialized: %s", info)
			return &sherpaEngine{
				recognizer: recognizer,
				hwInfo:     info,
			}, nil
		}
		logger.Info("Failed to init with %s, trying next provider", p.name)
	}

	return nil, fmt.Errorf("failed to initialize sherpa-onnx with any provider")
}

func offlineConfigForResolvedModel(resolved model.ResolvedModel, provider string) (sherpa.OfflineRecognizerConfig, error) {
	config := sherpa.OfflineRecognizerConfig{}
	config.FeatConfig.SampleRate = 16000
	config.FeatConfig.FeatureDim = 80
	config.ModelConfig.Tokens = resolved.Files["tokens"]
	config.ModelConfig.NumThreads = resolved.Profile.NumThreads
	config.ModelConfig.Provider = provider
	config.DecodingMethod = "greedy_search"

	switch resolved.BackendKind {
	case model.BackendSenseVoice:
		config.ModelConfig.SenseVoice.Model = resolved.Files["model"]
		config.ModelConfig.SenseVoice.UseInverseTextNormalization = 1
	case model.BackendMoonshine:
		config.ModelConfig.Moonshine.Preprocessor = resolved.Files["preprocessor"]
		config.ModelConfig.Moonshine.Encoder = resolved.Files["encoder"]
		config.ModelConfig.Moonshine.UncachedDecoder = resolved.Files["uncached_decoder"]
		config.ModelConfig.Moonshine.CachedDecoder = resolved.Files["cached_decoder"]
	case model.BackendNemoTransducer:
		config.ModelConfig.Transducer.Encoder = resolved.Files["encoder"]
		config.ModelConfig.Transducer.Decoder = resolved.Files["decoder"]
		config.ModelConfig.Transducer.Joiner = resolved.Files["joiner"]
		config.ModelConfig.ModelType = model.BackendNemoTransducer
	default:
		return sherpa.OfflineRecognizerConfig{}, fmt.Errorf("unsupported backend kind: %s", resolved.BackendKind)
	}

	return config, nil
}

func darwinProviders(providerOrder []string) []struct {
	name     string
	provider string
} {
	names := map[string]string{
		"coreml": "CoreML (Apple Neural Engine)",
		"cpu":    "CPU",
	}
	providers := make([]struct {
		name     string
		provider string
	}, 0, len(providerOrder))
	for _, provider := range providerOrder {
		name, ok := names[provider]
		if !ok {
			continue
		}
		providers = append(providers, struct {
			name     string
			provider string
		}{name: name, provider: provider})
	}
	if len(providers) == 0 {
		providers = append(providers, struct {
			name     string
			provider string
		}{name: "CPU", provider: "cpu"})
	}
	return providers
}

func (e *sherpaEngine) Recognize(samples []float32) (string, error) {
	stream := sherpa.NewOfflineStream(e.recognizer)
	defer sherpa.DeleteOfflineStream(stream)

	stream.AcceptWaveform(16000, samples)

	e.recognizer.Decode(stream)
	result := stream.GetResult()

	return result.Text, nil
}

func (e *sherpaEngine) HardwareInfo() string {
	return e.hwInfo
}

func (e *sherpaEngine) Close() {
	if e.recognizer != nil {
		sherpa.DeleteOfflineRecognizer(e.recognizer)
		e.recognizer = nil
	}
}