package engine

import (
	"fmt"
	"time"
	"voicesnap/internal/config"
	"voicesnap/internal/language"
	"voicesnap/internal/logger"
	"voicesnap/internal/model"
	"voicesnap/internal/modelselection"
	"voicesnap/internal/paths"
)

// Engine is the interface for ASR engines.
type Engine interface {
	// Recognize takes float32 PCM samples (16kHz mono) and returns the recognized text.
	Recognize(samples []float32) (string, error)
	// HardwareInfo returns a human-readable description of the hardware backend being used.
	HardwareInfo() string
	// Close releases engine resources.
	Close()
}

// StreamingEngine is implemented by engines that can expose partial results
// while audio is still being captured.
type StreamingEngine interface {
	NewStreamingSession() (StreamingSession, error)
}

// ReleaseTailCaptureEngine is implemented by engines that need a short audio
// capture grace period after the user releases the recording hotkey.
type ReleaseTailCaptureEngine interface {
	ReleaseTailCaptureDelay() time.Duration
}

// HoldPreCaptureEngine is implemented by engines that should start capturing
// audio immediately on hold-to-talk key down, before the activation delay has
// confirmed that the hotkey was not part of a key combination.
type HoldPreCaptureEngine interface {
	HoldPreCaptureEnabled() bool
}

// StreamingSession receives incremental 16kHz mono PCM and returns the current
// best transcript for the active utterance.
type StreamingSession interface {
	Accept(samples []float32) (string, error)
	Finish() (string, error)
	Close()
}

// ModelDir returns the path to the sensevoice model directory.
func ModelDir() string {
	resolved, err := resolveCurrentModel()
	if err == nil && resolved.IsUsable() {
		return resolved.RootDir
	}
	return paths.ModelDir()
}

// ModelPath returns the path to the ONNX model file (prefers int8).
func ModelPath() string {
	resolved, err := resolveCurrentModel()
	if err == nil && resolved.IsUsable() {
		return resolved.Files["model"]
	}
	return ""
}

// TokensPath returns the path to the tokens.txt file.
func TokensPath() string {
	resolved, err := resolveCurrentModel()
	if err == nil && resolved.IsUsable() {
		return resolved.Files["tokens"]
	}
	return ""
}

// ModelExists checks if both the model and tokens files exist.
func ModelExists() bool {
	resolved, err := resolveCurrentModel()
	if err != nil {
		return false
	}
	return resolved.IsUsable()
}

// New creates a new platform-specific ASR engine.
// Returns an error if the model files are not found.
func New() (Engine, error) {
	cfg, err := config.Load()
	if err != nil {
		logger.Error("Failed to load config for model selection: %v", err)
		cfg = config.Default()
	}
	current := modelselection.Resolve(cfg, language.NewSystemDetector())
	return NewWithModelID(current.ModelID)
}

func NewWithModelID(modelID string) (Engine, error) {
	resolved, err := model.ResolveModel(model.NormalizeModelID(modelID))
	if err != nil {
		return nil, err
	}
	return NewWithResolvedModel(resolved)
}

func NewWithResolvedModel(resolved model.ResolvedModel) (Engine, error) {
	if !resolved.IsUsable() {
		return nil, fmt.Errorf("model %s is not usable: %s missing=%v problems=%v", resolved.ModelID, resolved.Status, resolved.Missing, resolved.Problems)
	}
	if !isSupportedBackend(resolved.BackendKind) {
		return nil, fmt.Errorf("unsupported backend kind: %s", resolved.BackendKind)
	}

	logger.Info("Loading model %s backend=%s from %s", resolved.ModelID, resolved.BackendKind, resolved.RootDir)
	return newPlatformEngine(resolved)
}

func isSupportedBackend(backend string) bool {
	switch backend {
	case model.BackendSenseVoice, model.BackendMoonshine, model.BackendTransducer, model.BackendNemoTransducer, model.BackendQwen3ASR, model.BackendXASRStreaming:
		return true
	default:
		return false
	}
}

func resolveCurrentModel() (model.ResolvedModel, error) {
	cfg, err := config.Load()
	if err != nil {
		cfg = config.Default()
	}
	current := modelselection.Resolve(cfg, language.NewSystemDetector())
	return model.ResolveModel(current.ModelID)
}