package qmc

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"unicode/utf8"

	"jsuse.com/dev/dec-music/log"
	"jsuse.com/dev/dec-music/mmkv"
)

var streamKeyVault mmkv.Vault

func readKeyFromMMKV(file string, logger *log.Logger) ([]byte, error) {
	if file == "" {
		return nil, errors.New("file path is required while reading key from mmkv")
	}
	if runtime.GOOS != "darwin" {
		return nil, errors.New("mmkv vault not supported on this platform")
	}

	if streamKeyVault == nil {
		mmkvDir, err := getRelativeMMKVDir(file)
		if err != nil {
			mmkvDir, err = getDefaultMMKVDir()
			if err != nil {
				return nil, fmt.Errorf("mmkv key vault not found: %w", err)
			}
		}

		mgr, err := mmkv.NewManager(mmkvDir)
		if err != nil {
			return nil, fmt.Errorf("init mmkv manager: %w", err)
		}

		streamKeyVault, err = mgr.OpenVault("MMKVStreamEncryptId")
		if err != nil {
			return nil, fmt.Errorf("open mmkv vault: %w", err)
		}

		if logger != nil {
			logger.Debug("mmkv vault opened, keys:", len(streamKeyVault.Keys()))
		}
	}

	_, partName := filepath.Split(file)
	partName = normalizeUnicode(partName)

	buf, err := streamKeyVault.GetBytes(file)
	if buf == nil {
		filePaths := streamKeyVault.Keys()
		fileNames := make([]string, len(filePaths))
		for i, filePath := range filePaths {
			_, name := filepath.Split(filePath)
			fileNames[i] = normalizeUnicode(name)
		}

		for i, key := range fileNames {
			if key != partName {
				continue
			}
			buf, err = streamKeyVault.GetBytes(filePaths[i])
			if err != nil && logger != nil {
				logger.Warn("read key from mmkv", filePaths[i], err)
			}
			break
		}
	}

	if len(buf) == 0 {
		return nil, errors.New("key not found in mmkv vault")
	}
	return deriveKey(buf)
}

// OpenMMKVCLI opens a QQ Music MMKV vault (used by the CLI).
func OpenMMKVCLI(mmkvPath, key string, logger *log.Logger) error {
	return openMMKV(mmkvPath, key, logger)
}

func openMMKV(mmkvPath, key string, logger *log.Logger) error {
	filePath, fileName := filepath.Split(mmkvPath)
	mgr, err := mmkv.NewManager(filepath.Dir(filePath))
	if err != nil {
		return fmt.Errorf("init mmkv manager: %w", err)
	}

	streamKeyVault, err = mgr.OpenVaultCrypto(fileName, key)
	if err != nil {
		return fmt.Errorf("open mmkv vault: %w", err)
	}
	if logger != nil {
		logger.Debug("mmkv vault opened, keys:", len(streamKeyVault.Keys()))
	}
	return nil
}

func readKeyFromMMKVCustom(mid string) ([]byte, error) {
	if streamKeyVault == nil {
		return nil, fmt.Errorf("mmkv vault not loaded")
	}
	eKey, err := streamKeyVault.GetBytes(mid)
	if err != nil {
		return nil, fmt.Errorf("get eKey error: %w", err)
	}
	return deriveKey(eKey)
}

func getRelativeMMKVDir(file string) (string, error) {
	mmkvDir := filepath.Join(filepath.Dir(file), "../mmkv")
	if _, err := os.Stat(mmkvDir); err != nil {
		return "", err
	}
	keyFile := filepath.Join(mmkvDir, "MMKVStreamEncryptId")
	if _, err := os.Stat(keyFile); err != nil {
		return "", err
	}
	return mmkvDir, nil
}

func getDefaultMMKVDir() (string, error) {
	homeDir, err := os.UserHomeDir()
	if err != nil {
		return "", err
	}
	mmkvDir := filepath.Join(
		homeDir,
		"Library/Containers/com.tencent.QQMusicMac/Data",
		"Library/Application Support/QQMusicMac/mmkv",
	)
	if _, err := os.Stat(mmkvDir); err != nil {
		return "", err
	}
	keyFile := filepath.Join(mmkvDir, "MMKVStreamEncryptId")
	if _, err := os.Stat(keyFile); err != nil {
		return "", err
	}
	return mmkvDir, nil
}

// normalizeUnicode applies a simple NFC-like fix for macOS decomposed filenames.
func normalizeUnicode(str string) string {
	if utf8.ValidString(str) && !strings.ContainsRune(str, '\u0300') {
		return str
	}
	var b strings.Builder
	for _, r := range str {
		if r >= 0x0300 && r <= 0x036F {
			continue
		}
		b.WriteRune(r)
	}
	return b.String()
}