package drivers

import (
	"fmt"
	"math"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

type EnergyState struct {
	lastEnergy uint64
	lastTime   time.Time
}

type RaplDriver struct {
	energyState map[string]EnergyState
}

func NewRaplDriver() *RaplDriver {
	return &RaplDriver{
		energyState: map[string]EnergyState{},
	}

}

func (r *RaplDriver) ReadPowerSensors() ([]PowerSensor, error) {
	powerSensors := []PowerSensor{}

	patterns := []string{
		"/sys/class/powercap/intel-rapl*/energy_uj",
		"/sys/class/powercap/intel-rapl/intel-rapl*/energy_uj",
		"/sys/class/powercap/intel-rapl/intel-rapl*/*/energy_uj",
		"/sys/class/powercap/intel-rapl:*/energy_uj",
		"/sys/class/powercap/intel-rapl:*/*/energy_uj",
	}

	energyInputs := []string{}
	unique := make(map[string]bool)

	for _, pattern := range patterns {
		matches, _ := filepath.Glob(pattern)

		for _, match := range matches {
			realPath, err := filepath.EvalSymlinks(match)
			if err != nil {
				realPath = match
			}
			if !unique[realPath] {
				unique[realPath] = true
				energyInputs = append(energyInputs, realPath)
			}
		}
	}

	if len(energyInputs) == 0 {
		return powerSensors, fmt.Errorf("found no compatible rapl drivers")
	}

	r.calculateEnergyDelta(energyInputs, &powerSensors)
	return powerSensors, nil
}

func getRaplLabel(inputPath string) string {
	dir := filepath.Dir(inputPath)
	if nameBytes, err := os.ReadFile(filepath.Join(dir, "name")); err == nil {
		return strings.TrimSpace(string(nameBytes))
	}
	return filepath.Base(dir)
}

func (r *RaplDriver) calculateEnergyDelta(inputs []string, out *[]PowerSensor) {
	now := time.Now()

	if r.energyState == nil {
		r.energyState = make(map[string]EnergyState)
	}

	for _, rawPath := range inputs {
		key, err := filepath.EvalSymlinks(rawPath)
		if err != nil {
			key = filepath.Clean(rawPath)
		}

		valBytes, err := os.ReadFile(key)
		if err != nil {
			continue
		}

		microJoules, err := strconv.ParseUint(strings.TrimSpace(string(valBytes)), 10, 64)
		if err != nil {
			continue
		}

		prevState, exists := r.energyState[key]

		if !exists {
			r.energyState[key] = EnergyState{
				lastEnergy: microJoules,
				lastTime:   now,
			}
			*out = append(*out, PowerSensor{
				Name:  getRaplLabel(key),
				Watts: 0.0,
			})
			continue
		}

		timeDiff := now.Sub(prevState.lastTime).Seconds()
		if timeDiff < 0.05 {
			continue
		}

		maxRange := uint64(math.MaxUint64)
		rangeBytes, err := os.ReadFile(filepath.Join(filepath.Dir(key), "max_energy_range_uj"))
		if err == nil {
			if parsedMax, err := strconv.ParseUint(strings.TrimSpace(string(rangeBytes)), 10, 64); err == nil && parsedMax > 0 {
				maxRange = parsedMax
			}
		}

		var energyDiff uint64
		if microJoules >= prevState.lastEnergy {
			energyDiff = microJoules - prevState.lastEnergy
		} else {
			energyDiff = (maxRange - prevState.lastEnergy) + microJoules
		}

		watts := (float64(energyDiff) / 1_000_000.0) / timeDiff

		r.energyState[key] = EnergyState{
			lastEnergy: microJoules,
			lastTime:   now,
		}

		*out = append(*out, PowerSensor{
			Name:  getRaplLabel(key),
			Watts: watts,
		})
	}
}