package app

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"sort"
	"strconv"
	"strings"
	"time"

	"bee/audit/internal/collector"
	"bee/audit/internal/platform"
	"bee/audit/internal/runtimeenv"
	"bee/audit/internal/schema"
)

var (
	DefaultAuditJSONPath = "/var/log/bee-audit.json"
	DefaultAuditLogPath  = "/var/log/bee-audit.log"
	DefaultSATBaseDir    = "/var/log/bee-sat"
)

type App struct {
	network  networkManager
	services serviceManager
	exports  exportManager
	tools    toolManager
	sat      satRunner
}

type ActionResult struct {
	Title string
	Body  string
}

type networkManager interface {
	ListInterfaces() ([]platform.InterfaceInfo, error)
	DefaultRoute() string
	DHCPOne(iface string) (string, error)
	DHCPAll() (string, error)
	SetStaticIPv4(cfg platform.StaticIPv4Config) (string, error)
}

type serviceManager interface {
	ListBeeServices() ([]string, error)
	ServiceStatus(name string) (string, error)
	ServiceDo(name string, action platform.ServiceAction) (string, error)
}

type exportManager interface {
	ListRemovableTargets() ([]platform.RemovableTarget, error)
	ExportFileToTarget(src string, target platform.RemovableTarget) (string, error)
}

type toolManager interface {
	TailFile(path string, lines int) string
	CheckTools(names []string) []platform.ToolStatus
}

type satRunner interface {
	RunNvidiaAcceptancePack(baseDir string) (string, error)
	RunMemoryAcceptancePack(baseDir string) (string, error)
	RunStorageAcceptancePack(baseDir string) (string, error)
}

func New(platform *platform.System) *App {
	return &App{
		network:  platform,
		services: platform,
		exports:  platform,
		tools:    platform,
		sat:      platform,
	}
}

func (a *App) RunAudit(runtimeMode runtimeenv.Mode, output string) (string, error) {
	result := collector.Run(runtimeMode)
	data, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		return "", err
	}

	switch {
	case output == "stdout":
		_, err := os.Stdout.Write(append(data, '\n'))
		return "stdout", err
	case strings.HasPrefix(output, "file:"):
		path := strings.TrimPrefix(output, "file:")
		if err := os.WriteFile(path, append(data, '\n'), 0644); err != nil {
			return "", err
		}
		return path, nil
	default:
		return "", fmt.Errorf("unknown output destination %q — use stdout or file:<path>", output)
	}
}

func (a *App) RunAuditNow(runtimeMode runtimeenv.Mode) (ActionResult, error) {
	path, err := a.RunAudit(runtimeMode, "file:"+DefaultAuditJSONPath)
	body := "Audit completed."
	if path != "" {
		body = "Audit output: " + path
	}
	return ActionResult{Title: "Run audit", Body: body}, err
}

func (a *App) RunAuditToDefaultFile(runtimeMode runtimeenv.Mode) (string, error) {
	return a.RunAudit(runtimeMode, "file:"+DefaultAuditJSONPath)
}

func (a *App) ExportLatestAudit(target platform.RemovableTarget) (string, error) {
	if _, err := os.Stat(DefaultAuditJSONPath); err != nil {
		return "", err
	}
	filename := fmt.Sprintf("audit-%s-%s.json", sanitizeFilename(hostnameOr("unknown")), time.Now().UTC().Format("20060102-150405"))
	tmpPath := filepath.Join(os.TempDir(), filename)
	data, err := os.ReadFile(DefaultAuditJSONPath)
	if err != nil {
		return "", err
	}
	if err := os.WriteFile(tmpPath, data, 0644); err != nil {
		return "", err
	}
	defer os.Remove(tmpPath)
	return a.exports.ExportFileToTarget(tmpPath, target)
}

func (a *App) ExportLatestAuditResult(target platform.RemovableTarget) (ActionResult, error) {
	path, err := a.ExportLatestAudit(target)
	body := "Audit exported."
	if path != "" {
		body = "Audit exported to " + path
	}
	return ActionResult{Title: "Export audit", Body: body}, err
}

func (a *App) ListInterfaces() ([]platform.InterfaceInfo, error) {
	return a.network.ListInterfaces()
}

func (a *App) DefaultRoute() string {
	return a.network.DefaultRoute()
}

func (a *App) DHCPOne(iface string) (string, error) {
	return a.network.DHCPOne(iface)
}

func (a *App) DHCPOneResult(iface string) (ActionResult, error) {
	body, err := a.network.DHCPOne(iface)
	return ActionResult{Title: "DHCP: " + iface, Body: bodyOr(body, "DHCP completed.")}, err
}

func (a *App) DHCPAll() (string, error) {
	return a.network.DHCPAll()
}

func (a *App) DHCPAllResult() (ActionResult, error) {
	body, err := a.network.DHCPAll()
	return ActionResult{Title: "DHCP: all interfaces", Body: bodyOr(body, "DHCP completed.")}, err
}

func (a *App) SetStaticIPv4(cfg platform.StaticIPv4Config) (string, error) {
	return a.network.SetStaticIPv4(cfg)
}

func (a *App) SetStaticIPv4Result(cfg platform.StaticIPv4Config) (ActionResult, error) {
	body, err := a.network.SetStaticIPv4(cfg)
	return ActionResult{Title: "Static IPv4: " + cfg.Interface, Body: bodyOr(body, "Static IPv4 updated.")}, err
}

func (a *App) NetworkStatus() (ActionResult, error) {
	ifaces, err := a.network.ListInterfaces()
	if err != nil {
		return ActionResult{Title: "Network status"}, err
	}
	if len(ifaces) == 0 {
		return ActionResult{Title: "Network status", Body: "No physical interfaces found."}, nil
	}
	var body strings.Builder
	for _, iface := range ifaces {
		ipv4 := "(no IPv4)"
		if len(iface.IPv4) > 0 {
			ipv4 = strings.Join(iface.IPv4, ", ")
		}
		fmt.Fprintf(&body, "- %s: state=%s ip=%s\n", iface.Name, iface.State, ipv4)
	}
	if gw := a.network.DefaultRoute(); gw != "" {
		fmt.Fprintf(&body, "\nDefault route: %s\n", gw)
	}
	return ActionResult{Title: "Network status", Body: strings.TrimSpace(body.String())}, nil
}

func (a *App) DefaultStaticIPv4FormFields(iface string) []string {
	return []string{
		"",
		"24",
		strings.TrimSpace(a.network.DefaultRoute()),
		"77.88.8.8 77.88.8.1 1.1.1.1 8.8.8.8",
	}
}

func (a *App) ParseStaticIPv4Config(iface string, fields []string) platform.StaticIPv4Config {
	get := func(index int) string {
		if index >= 0 && index < len(fields) {
			return strings.TrimSpace(fields[index])
		}
		return ""
	}
	return platform.StaticIPv4Config{
		Interface: iface,
		Address:   get(0),
		Prefix:    get(1),
		Gateway:   get(2),
		DNS:       strings.Fields(get(3)),
	}
}

func (a *App) ListBeeServices() ([]string, error) {
	return a.services.ListBeeServices()
}

func (a *App) ServiceStatus(name string) (string, error) {
	return a.services.ServiceStatus(name)
}

func (a *App) ServiceStatusResult(name string) (ActionResult, error) {
	body, err := a.services.ServiceStatus(name)
	return ActionResult{Title: "service status: " + name, Body: bodyOr(body, "No status output.")}, err
}

func (a *App) ServiceDo(name string, action platform.ServiceAction) (string, error) {
	return a.services.ServiceDo(name, action)
}

func (a *App) ServiceActionResult(name string, action platform.ServiceAction) (ActionResult, error) {
	body, err := a.services.ServiceDo(name, action)
	return ActionResult{Title: "service " + string(action) + ": " + name, Body: bodyOr(body, "Action completed.")}, err
}

func (a *App) ListRemovableTargets() ([]platform.RemovableTarget, error) {
	return a.exports.ListRemovableTargets()
}

func (a *App) TailFile(path string, lines int) string {
	return a.tools.TailFile(path, lines)
}

func (a *App) CheckTools(names []string) []platform.ToolStatus {
	return a.tools.CheckTools(names)
}

func (a *App) ToolCheckResult(names []string) ActionResult {
	if len(names) == 0 {
		return ActionResult{Title: "Required tools", Body: "No tools checked."}
	}
	var body strings.Builder
	for _, tool := range a.tools.CheckTools(names) {
		status := "MISSING"
		if tool.OK {
			status = "OK (" + tool.Path + ")"
		}
		fmt.Fprintf(&body, "- %s: %s\n", tool.Name, status)
	}
	return ActionResult{Title: "Required tools", Body: strings.TrimSpace(body.String())}
}

func (a *App) AuditLogTailResult() ActionResult {
	logTail := strings.TrimSpace(a.tools.TailFile(DefaultAuditLogPath, 40))
	jsonTail := strings.TrimSpace(a.tools.TailFile(DefaultAuditJSONPath, 20))
	body := strings.TrimSpace(logTail + "\n\n" + jsonTail)
	if body == "" {
		body = "No audit logs found."
	}
	return ActionResult{Title: "Audit log tail", Body: body}
}

func (a *App) RunNvidiaAcceptancePack(baseDir string) (string, error) {
	return a.sat.RunNvidiaAcceptancePack(baseDir)
}

func (a *App) RunNvidiaAcceptancePackResult(baseDir string) (ActionResult, error) {
	path, err := a.sat.RunNvidiaAcceptancePack(baseDir)
	body := "Archive written."
	if path != "" {
		body = "Archive written to " + path
	}
	return ActionResult{Title: "NVIDIA SAT", Body: body}, err
}

func (a *App) RunMemoryAcceptancePack(baseDir string) (string, error) {
	return a.sat.RunMemoryAcceptancePack(baseDir)
}

func (a *App) RunMemoryAcceptancePackResult(baseDir string) (ActionResult, error) {
	path, err := a.sat.RunMemoryAcceptancePack(baseDir)
	body := "Archive written."
	if path != "" {
		body = "Archive written to " + path
	}
	return ActionResult{Title: "Memory SAT", Body: body}, err
}

func (a *App) RunStorageAcceptancePack(baseDir string) (string, error) {
	return a.sat.RunStorageAcceptancePack(baseDir)
}

func (a *App) RunStorageAcceptancePackResult(baseDir string) (ActionResult, error) {
	path, err := a.sat.RunStorageAcceptancePack(baseDir)
	body := "Archive written."
	if path != "" {
		body = "Archive written to " + path
	}
	return ActionResult{Title: "Storage SAT", Body: body}, err
}

func (a *App) HealthSummaryResult() ActionResult {
	type auditFile struct {
		Hardware struct {
			Summary struct {
				Status      string   `json:"status"`
				Warnings    []string `json:"warnings"`
				Failures    []string `json:"failures"`
				StorageWarn int      `json:"storage_warn"`
				StorageFail int      `json:"storage_fail"`
				PCIeWarn    int      `json:"pcie_warn"`
				PCIeFail    int      `json:"pcie_fail"`
				PSUWarn     int      `json:"psu_warn"`
				PSUFail     int      `json:"psu_fail"`
				MemoryWarn  int      `json:"memory_warn"`
				MemoryFail  int      `json:"memory_fail"`
			} `json:"summary"`
		} `json:"hardware"`
	}

	raw, err := os.ReadFile(DefaultAuditJSONPath)
	if err != nil {
		return ActionResult{Title: "Health summary", Body: "No audit JSON found."}
	}
	var snapshot auditFile
	if err := json.Unmarshal(raw, &snapshot); err != nil {
		return ActionResult{Title: "Health summary", Body: "Audit JSON is unreadable."}
	}

	summary := snapshot.Hardware.Summary
	var body strings.Builder
	status := summary.Status
	if status == "" {
		status = "UNKNOWN"
	}
	fmt.Fprintf(&body, "Overall: %s\n", status)
	fmt.Fprintf(&body, "Storage: warn=%d fail=%d\n", summary.StorageWarn, summary.StorageFail)
	fmt.Fprintf(&body, "PCIe: warn=%d fail=%d\n", summary.PCIeWarn, summary.PCIeFail)
	fmt.Fprintf(&body, "PSU: warn=%d fail=%d\n", summary.PSUWarn, summary.PSUFail)
	fmt.Fprintf(&body, "Memory: warn=%d fail=%d\n", summary.MemoryWarn, summary.MemoryFail)
	for _, item := range latestSATSummaries() {
		fmt.Fprintf(&body, "\n\n%s", item)
	}
	if len(summary.Failures) > 0 {
		fmt.Fprintf(&body, "\n\nFailures:\n- %s", strings.Join(summary.Failures, "\n- "))
	}
	if len(summary.Warnings) > 0 {
		fmt.Fprintf(&body, "\n\nWarnings:\n- %s", strings.Join(summary.Warnings, "\n- "))
	}
	return ActionResult{Title: "Health summary", Body: strings.TrimSpace(body.String())}
}

func (a *App) MainBanner() string {
	raw, err := os.ReadFile(DefaultAuditJSONPath)
	if err != nil {
		return ""
	}

	var snapshot schema.HardwareIngestRequest
	if err := json.Unmarshal(raw, &snapshot); err != nil {
		return ""
	}

	var lines []string
	if system := formatSystemLine(snapshot.Hardware.Board); system != "" {
		lines = append(lines, system)
	}
	if cpu := formatCPULine(snapshot.Hardware.CPUs); cpu != "" {
		lines = append(lines, cpu)
	}
	if memory := formatMemoryLine(snapshot.Hardware.Memory); memory != "" {
		lines = append(lines, memory)
	}
	if storage := formatStorageLine(snapshot.Hardware.Storage); storage != "" {
		lines = append(lines, storage)
	}
	if gpu := formatGPULine(snapshot.Hardware.PCIeDevices); gpu != "" {
		lines = append(lines, gpu)
	}
	if ip := formatIPLine(a.network.ListInterfaces); ip != "" {
		lines = append(lines, ip)
	}

	return strings.TrimSpace(strings.Join(lines, "\n"))
}

func (a *App) FormatToolStatuses(statuses []platform.ToolStatus) string {
	var body strings.Builder
	for _, tool := range statuses {
		status := "MISSING"
		if tool.OK {
			status = "OK (" + tool.Path + ")"
		}
		fmt.Fprintf(&body, "- %s: %s\n", tool.Name, status)
	}
	return strings.TrimSpace(body.String())
}

func (a *App) ParsePrefix(raw string, fallback int) int {
	value, err := strconv.Atoi(strings.TrimSpace(raw))
	if err != nil || value <= 0 {
		return fallback
	}
	return value
}

func hostnameOr(fallback string) string {
	hn, err := os.Hostname()
	if err != nil || strings.TrimSpace(hn) == "" {
		return fallback
	}
	return hn
}

func sanitizeFilename(v string) string {
	var out []rune
	for _, r := range v {
		switch {
		case r >= 'a' && r <= 'z', r >= 'A' && r <= 'Z', r >= '0' && r <= '9', r == '-', r == '_', r == '.':
			out = append(out, r)
		default:
			out = append(out, '-')
		}
	}
	if len(out) == 0 {
		return "unknown"
	}
	return string(out)
}

func bodyOr(body, fallback string) string {
	body = strings.TrimSpace(body)
	if body == "" {
		return fallback
	}
	return body
}

func latestSATSummaries() []string {
	patterns := []struct {
		label  string
		prefix string
	}{
		{label: "NVIDIA SAT", prefix: "gpu-nvidia-"},
		{label: "Memory SAT", prefix: "memory-"},
		{label: "Storage SAT", prefix: "storage-"},
	}
	var out []string
	for _, item := range patterns {
		matches, err := filepath.Glob(filepath.Join(DefaultSATBaseDir, item.prefix+"*/summary.txt"))
		if err != nil || len(matches) == 0 {
			continue
		}
		sort.Strings(matches)
		raw, err := os.ReadFile(matches[len(matches)-1])
		if err != nil {
			continue
		}
		out = append(out, formatSATSummary(item.label, string(raw)))
	}
	return out
}

func formatSATSummary(label, raw string) string {
	values := parseKeyValueSummary(raw)
	var body strings.Builder
	fmt.Fprintf(&body, "%s:", label)
	if overall := firstNonEmpty(values["overall_status"], "UNKNOWN"); overall != "" {
		fmt.Fprintf(&body, " %s", overall)
	}
	if ok := firstNonEmpty(values["job_ok"], "0"); ok != "" {
		fmt.Fprintf(&body, " ok=%s", ok)
	}
	if failed := firstNonEmpty(values["job_failed"], "0"); failed != "" {
		fmt.Fprintf(&body, " failed=%s", failed)
	}
	if unsupported := firstNonEmpty(values["job_unsupported"], "0"); unsupported != "" && unsupported != "0" {
		fmt.Fprintf(&body, " unsupported=%s", unsupported)
	}
	if devices := strings.TrimSpace(values["devices"]); devices != "" {
		fmt.Fprintf(&body, "\nDevices: %s", devices)
	}
	return body.String()
}

func formatSystemLine(board schema.HardwareBoard) string {
	model := strings.TrimSpace(strings.Join([]string{
		trimPtr(board.Manufacturer),
		trimPtr(board.ProductName),
	}, " "))
	serial := strings.TrimSpace(board.SerialNumber)
	switch {
	case model != "" && serial != "":
		return fmt.Sprintf("System: %s | S/N %s", model, serial)
	case model != "":
		return "System: " + model
	case serial != "":
		return "System S/N: " + serial
	default:
		return ""
	}
}

func formatCPULine(cpus []schema.HardwareCPU) string {
	if len(cpus) == 0 {
		return ""
	}
	modelCounts := map[string]int{}
	unknown := 0
	for _, cpu := range cpus {
		model := trimPtr(cpu.Model)
		if model == "" {
			unknown++
			continue
		}
		modelCounts[model]++
	}
	if len(modelCounts) == 1 && unknown == 0 {
		for model, count := range modelCounts {
			return fmt.Sprintf("CPU: %d x %s", count, model)
		}
	}
	parts := make([]string, 0, len(modelCounts)+1)
	if len(modelCounts) > 0 {
		keys := make([]string, 0, len(modelCounts))
		for key := range modelCounts {
			keys = append(keys, key)
		}
		sort.Strings(keys)
		for _, key := range keys {
			parts = append(parts, fmt.Sprintf("%d x %s", modelCounts[key], key))
		}
	}
	if unknown > 0 {
		parts = append(parts, fmt.Sprintf("%d x unknown", unknown))
	}
	return "CPU: " + strings.Join(parts, ", ")
}

func formatMemoryLine(dimms []schema.HardwareMemory) string {
	totalMB := 0
	present := 0
	types := map[string]struct{}{}
	for _, dimm := range dimms {
		if dimm.Present != nil && !*dimm.Present {
			continue
		}
		if dimm.SizeMB == nil || *dimm.SizeMB <= 0 {
			continue
		}
		present++
		totalMB += *dimm.SizeMB
		if value := trimPtr(dimm.Type); value != "" {
			types[value] = struct{}{}
		}
	}
	if totalMB == 0 {
		return ""
	}
	typeText := joinSortedKeys(types)
	line := fmt.Sprintf("Memory: %s", humanizeMB(totalMB))
	if typeText != "" {
		line += " " + typeText
	}
	if present > 0 {
		line += fmt.Sprintf(" (%d DIMMs)", present)
	}
	return line
}

func formatStorageLine(disks []schema.HardwareStorage) string {
	count := 0
	totalGB := 0
	for _, disk := range disks {
		if disk.Present != nil && !*disk.Present {
			continue
		}
		count++
		if disk.SizeGB != nil && *disk.SizeGB > 0 {
			totalGB += *disk.SizeGB
		}
	}
	if count == 0 {
		return ""
	}
	line := fmt.Sprintf("Storage: %d drives", count)
	if totalGB > 0 {
		line += fmt.Sprintf(" / %s", humanizeGB(totalGB))
	}
	return line
}

func formatGPULine(devices []schema.HardwarePCIeDevice) string {
	gpus := map[string]int{}
	for _, dev := range devices {
		if !isGPUDevice(dev) {
			continue
		}
		name := firstNonEmpty(trimPtr(dev.Model), trimPtr(dev.Manufacturer), "unknown")
		gpus[name]++
	}
	if len(gpus) == 0 {
		return ""
	}
	keys := make([]string, 0, len(gpus))
	for key := range gpus {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	parts := make([]string, 0, len(keys))
	for _, key := range keys {
		parts = append(parts, fmt.Sprintf("%d x %s", gpus[key], key))
	}
	return "GPU: " + strings.Join(parts, ", ")
}

func formatIPLine(list func() ([]platform.InterfaceInfo, error)) string {
	if list == nil {
		return ""
	}
	ifaces, err := list()
	if err != nil {
		return ""
	}
	seen := map[string]struct{}{}
	var ips []string
	for _, iface := range ifaces {
		for _, ip := range iface.IPv4 {
			ip = strings.TrimSpace(ip)
			if ip == "" {
				continue
			}
			if _, ok := seen[ip]; ok {
				continue
			}
			seen[ip] = struct{}{}
			ips = append(ips, ip)
		}
	}
	if len(ips) == 0 {
		return ""
	}
	sort.Strings(ips)
	return "IP: " + strings.Join(ips, ", ")
}

func isGPUDevice(dev schema.HardwarePCIeDevice) bool {
	class := strings.ToLower(trimPtr(dev.DeviceClass))
	model := strings.ToLower(trimPtr(dev.Model))
	vendor := strings.ToLower(trimPtr(dev.Manufacturer))
	return strings.Contains(class, "vga") ||
		strings.Contains(class, "3d") ||
		strings.Contains(class, "display") ||
		strings.Contains(model, "nvidia") ||
		strings.Contains(vendor, "nvidia") ||
		strings.Contains(vendor, "amd")
}

func trimPtr(value *string) string {
	if value == nil {
		return ""
	}
	return strings.TrimSpace(*value)
}

func joinSortedKeys(values map[string]struct{}) string {
	if len(values) == 0 {
		return ""
	}
	keys := make([]string, 0, len(values))
	for key := range values {
		keys = append(keys, key)
	}
	sort.Strings(keys)
	return strings.Join(keys, "/")
}

func humanizeMB(totalMB int) string {
	if totalMB <= 0 {
		return ""
	}
	gb := float64(totalMB) / 1024.0
	if gb >= 1024.0 {
		tb := gb / 1024.0
		return fmt.Sprintf("%.1f TB", tb)
	}
	if gb == float64(int64(gb)) {
		return fmt.Sprintf("%.0f GB", gb)
	}
	return fmt.Sprintf("%.1f GB", gb)
}

func humanizeGB(totalGB int) string {
	if totalGB <= 0 {
		return ""
	}
	tb := float64(totalGB) / 1024.0
	if tb >= 1.0 {
		return fmt.Sprintf("%.1f TB", tb)
	}
	return fmt.Sprintf("%d GB", totalGB)
}

func parseKeyValueSummary(raw string) map[string]string {
	out := map[string]string{}
	for _, line := range strings.Split(raw, "\n") {
		line = strings.TrimSpace(line)
		if line == "" {
			continue
		}
		key, value, ok := strings.Cut(line, "=")
		if !ok {
			continue
		}
		out[strings.TrimSpace(key)] = strings.TrimSpace(value)
	}
	return out
}

func firstNonEmpty(values ...string) string {
	for _, value := range values {
		value = strings.TrimSpace(value)
		if value != "" {
			return value
		}
	}
	return ""
}