package installer

import (
	"context"
	"fmt"

	"yizhisec.com/hsv2/forge/pkg/logger"
	"yizhisec.com/hsv2/forge/pkg/syscheck"
)

type CheckOption func(*checkOpt)
type checkOpt struct {
	ignoreDisk   bool
	ignoreMemory bool
	ignoreCPU    bool
}

func WithIgnoreDiskCheck(ignore bool) CheckOption {
	return func(o *checkOpt) {
		o.ignoreDisk = ignore
	}
}

func WithIgnoreMemoryCheck(ignore bool) CheckOption {
	return func(o *checkOpt) {
		o.ignoreMemory = ignore
	}
}

func WithIgnoreCPUCheck(ignore bool) CheckOption {
	return func(o *checkOpt) {
		o.ignoreCPU = ignore
	}
}

func (i *installer) Check(ctx context.Context, opts ...CheckOption) error {
	var (
		err error
		o   = &checkOpt{}
	)

	for _, fn := range opts {
		fn(o)
	}

	logger.Info("☑️ installer.Check: Starting system checks...")

	if err = i.targetOK(ctx); err != nil {
		return err
	}

	// 1. Check disk space: >= 500GB
	logger.Info("☑️ installer.Check: Checking disk space...")
	diskSpaceResult, err := syscheck.CheckDiskSpace(ctx, i, 500)
	if err != nil {
		logger.Debug("❌ installer.Check: Failed to check disk space: %v", err)
		return fmt.Errorf("failed to check disk space: %w", err)
	}

	if !diskSpaceResult.Passed {
		logger.Error("❌ %s: %s (Expected: %s, Actual: %s)", diskSpaceResult.Name, diskSpaceResult.Message, diskSpaceResult.Expected, diskSpaceResult.Actual)
		if !o.ignoreDisk {
			return fmt.Errorf("disk space check failed: %s", diskSpaceResult.Message)
		}
	}

	logger.Info("✅ %s: %s", diskSpaceResult.Name, diskSpaceResult.Actual)

	// 2. Check disk performance: write >= 500MB/s, read >= 500MB/s
	logger.Info("☑️ installer.Check: Checking disk performance...")
	diskPerfResult, err := syscheck.CheckDiskPerformance(ctx, i, 500, 500)
	if err != nil {
		logger.Debug("❌ installer.Check: Failed to check disk performance: %v", err)
		return fmt.Errorf("failed to check disk performance: %w", err)
	}

	if !diskPerfResult.Passed {
		logger.Error("❌ %s: %s (Expected: %s, Actual: %s)", diskPerfResult.Name, diskPerfResult.Message, diskPerfResult.Expected, diskPerfResult.Actual)
		if !o.ignoreDisk {
			return fmt.Errorf("disk performance check failed: %s", diskPerfResult.Message)
		}
	}

	logger.Info("✅ %s: %s", diskPerfResult.Name, diskPerfResult.Actual)

	// 3. Check memory size: >= 15.5GB
	logger.Info("☑️ installer.Check: Checking memory size...")
	memResult, err := syscheck.CheckMemory(ctx, i, 15.5)
	if err != nil {
		logger.Debug("❌ installer.Check: Failed to check memory: %v", err)
		return fmt.Errorf("failed to check memory: %w", err)
	}

	if !memResult.Passed {
		logger.Error("❌ %s: %s (Expected: %s, Actual: %s)", memResult.Name, memResult.Message, memResult.Expected, memResult.Actual)
		if !o.ignoreMemory {
			return fmt.Errorf("memory check failed: %s", memResult.Message)
		}
	}

	logger.Info("✅ %s: %s", memResult.Name, memResult.Actual)

	// 4. Check CPU cores: >= 8
	logger.Info("☑️ installer.Check: Checking CPU cores...")
	cpuCoresResult, err := syscheck.CheckCPUCores(ctx, i, 8)
	if err != nil {
		logger.Debug("❌ installer.Check: Failed to check CPU cores: %v", err)
		return fmt.Errorf("failed to check CPU cores: %w", err)
	}

	if !cpuCoresResult.Passed {
		logger.Error("❌ %s: %s (Expected: %s, Actual: %s)", cpuCoresResult.Name, cpuCoresResult.Message, cpuCoresResult.Expected, cpuCoresResult.Actual)
		if !o.ignoreCPU {
			return fmt.Errorf("CPU cores check failed: %s", cpuCoresResult.Message)
		}
	}

	logger.Info("✅ %s: %s", cpuCoresResult.Name, cpuCoresResult.Actual)

	// 5. Check CPU frequency: >= 2GHz
	logger.Info("☑️ installer.Check: Checking CPU frequency...")
	cpuFreqResult, err := syscheck.CheckCPUFrequency(ctx, i, 2.0)
	if err != nil {
		logger.Debug("❌ installer.Check: Failed to check CPU frequency: %v", err)
		return fmt.Errorf("failed to check CPU frequency: %w", err)
	}

	if !cpuFreqResult.Passed {
		logger.Error("❌ %s: %s (Expected: %s, Actual: %s)", cpuFreqResult.Name, cpuFreqResult.Message, cpuFreqResult.Expected, cpuFreqResult.Actual)
		if !o.ignoreCPU {
			return fmt.Errorf("CPU frequency check failed: %s", cpuFreqResult.Message)
		}
	}

	logger.Info("✅ %s: %s", cpuFreqResult.Name, cpuFreqResult.Actual)

	logger.Info("✅ installer.Check: All system checks passed successfully!")

	return nil
}