package services

import (
	"archive/zip"
	"encoding/json"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"runtime"
	"time"
	"voicesnap/internal/config"
	"voicesnap/internal/model"
	"voicesnap/internal/modelselection"
	"voicesnap/internal/paths"
)

type DiagnosticsService struct {
	cfg     *config.Config
	version string
}

func NewDiagnosticsService(cfg *config.Config, version string) *DiagnosticsService {
	if cfg == nil {
		cfg = config.Default()
	}
	return &DiagnosticsService{cfg: cfg, version: version}
}

func (s *DiagnosticsService) GetRuntimeStats() map[string]interface{} {
	var mem runtime.MemStats
	runtime.ReadMemStats(&mem)
	return map[string]interface{}{
		"version":       s.version,
		"goos":          runtime.GOOS,
		"goarch":        runtime.GOARCH,
		"go_version":    runtime.Version(),
		"goroutines":    runtime.NumGoroutine(),
		"cpu_count":     runtime.NumCPU(),
		"heap_alloc_mb": bytesToMiB(mem.HeapAlloc),
		"heap_sys_mb":   bytesToMiB(mem.HeapSys),
		"stack_sys_mb":  bytesToMiB(mem.StackSys),
		"next_gc_mb":    bytesToMiB(mem.NextGC),
		"num_gc":        mem.NumGC,
		"data_dir":      paths.AppSupportDir(),
		"models_dir":    paths.ModelsRoot(),
	}
}

func (s *DiagnosticsService) ExportDiagnostics() (string, error) {
	dir := filepath.Join(paths.AppSupportDir(), "diagnostics")
	if err := os.MkdirAll(dir, 0755); err != nil {
		return "", err
	}
	outPath := filepath.Join(dir, "privatevoice-diagnostics-"+time.Now().Format("20060102-150405")+".zip")

	out, err := os.Create(outPath)
	if err != nil {
		return "", err
	}
	defer out.Close()

	zw := zip.NewWriter(out)
	if err := s.addJSON(zw, "runtime.json", s.GetRuntimeStats()); err != nil {
		zw.Close()
		return "", err
	}
	if err := s.addJSON(zw, "config.redacted.json", redactedConfig(s.cfg)); err != nil {
		zw.Close()
		return "", err
	}
	if err := s.addJSON(zw, "models.json", modelDiagnostics(s.cfg)); err != nil {
		zw.Close()
		return "", err
	}
	if err := addLogFiles(zw); err != nil {
		zw.Close()
		return "", err
	}
	if err := zw.Close(); err != nil {
		return "", err
	}
	return outPath, nil
}

func (s *DiagnosticsService) addJSON(zw *zip.Writer, name string, value interface{}) error {
	data, err := json.MarshalIndent(value, "", "  ")
	if err != nil {
		return err
	}
	w, err := zw.Create(name)
	if err != nil {
		return err
	}
	_, err = w.Write(append(data, '\n'))
	return err
}

func addLogFiles(zw *zip.Writer) error {
	for _, name := range []string{"app.log", "app.log.1", "app.log.2", "app.log.3"} {
		path := filepath.Join(paths.AppSupportDir(), name)
		if err := addFileIfExists(zw, path, filepath.Join("logs", name)); err != nil {
			return err
		}
	}
	return nil
}

func addFileIfExists(zw *zip.Writer, path, zipName string) error {
	in, err := os.Open(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil
		}
		return err
	}
	defer in.Close()

	info, err := in.Stat()
	if err != nil {
		return err
	}
	header, err := zip.FileInfoHeader(info)
	if err != nil {
		return err
	}
	header.Name = zipName
	header.Method = zip.Deflate
	w, err := zw.CreateHeader(header)
	if err != nil {
		return err
	}
	_, err = io.Copy(w, in)
	return err
}

func redactedConfig(cfg *config.Config) map[string]interface{} {
	if cfg == nil {
		cfg = config.Default()
	}
	return map[string]interface{}{
		"HotkeyVK":           cfg.HotkeyVK,
		"HotkeyMode":         cfg.HotkeyMode,
		"AutoHide":           cfg.AutoHide,
		"SoundFeedback":      cfg.SoundFeedback,
		"HideDockIcon":       cfg.HideDockIcon,
		"CopyToClipboard":    cfg.CopyToClipboard,
		"DeviceNameSet":      cfg.DeviceName != "",
		"SelectedModelID":    cfg.SelectedModelID,
		"ModelSelectionMode": cfg.ModelSelectionMode,
		"LanguageMode":       cfg.LanguageMode,
		"LanguageID":         cfg.LanguageID,
	}
}

func modelDiagnostics(cfg *config.Config) map[string]interface{} {
	current := modelselection.Resolve(cfg, nil)
	items := make([]map[string]interface{}, 0)
	for _, profile := range model.ListModelProfiles() {
		resolved, err := model.ResolveModel(profile.ID)
		item := map[string]interface{}{
			"model_id":      profile.ID,
			"display_name":  profile.DisplayName,
			"backend":       profile.BackendKind,
			"tier":          profile.Tier,
			"num_threads":   profile.NumThreads,
			"current":       profile.ID == current.ModelID,
			"supported":     model.IsModelSupportedInCurrentBuild(profile.ID),
			"download_size": profile.ApproxSize,
		}
		if err != nil {
			item["status"] = "resolve_error"
			item["error"] = err.Error()
		} else {
			item["status"] = string(resolved.Status)
			item["usable"] = resolved.IsUsable()
			item["source_dir_kind"] = resolved.SourceDirKind
			item["missing"] = resolved.Missing
			item["problems"] = resolved.Problems
		}
		items = append(items, item)
	}
	return map[string]interface{}{
		"current_model_id":      current.ModelID,
		"selection_mode":        current.SelectionMode,
		"effective_language_id": current.LanguageSettings.EffectiveLanguageID,
		"fallback_reason":       current.FallbackReason,
		"has_any_usable_model":  model.HasAnyUsableModel(),
		"supported_build_note":  fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH),
		"models":                items,
	}
}

func bytesToMiB(value uint64) float64 {
	return float64(value) / 1024.0 / 1024.0
}