// Package state bewaart wat BlueGit nodig heeft vóór de datadisk gekozen is:
// de database, de sleutel en het gekozen opslagpad. De standaardmap is
// /var/lib/bluegit, de StateDirectory van systemd.
package state

import (
	"context"
	"errors"
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"strings"
	"syscall"

	"gitlab.com/Timfa/bluegit/internal/i18n"
)

// DefaultDir is de state-map als state_path leeg is.
const DefaultDir = "/var/lib/bluegit"

// File is de naam van het bestand met het gekozen opslagpad.
const File = "storage_path"

// MinFreeBytes is de kleinste vrije ruimte die een datadisk mag hebben.
const MinFreeBytes = 1 << 30

// Dir kiest de state-map. Een gezet pad wint van de standaard.
func Dir(configured string) string {
	if strings.TrimSpace(configured) != "" {
		return strings.TrimSpace(configured)
	}
	return DefaultDir
}

// Read leest het opgeslagen pad. Een ontbrekend bestand is geen fout
// en geeft een lege string.
func Read(dir string) (string, error) {
	b, err := os.ReadFile(filepath.Join(dir, File))
	if errors.Is(err, os.ErrNotExist) {
		return "", nil
	}
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(b)), nil
}

// Write zet het pad atomisch neer.
func Write(dir, path string) error {
	if err := os.MkdirAll(dir, 0o750); err != nil {
		return err
	}
	target := filepath.Join(dir, File)
	tmp := target + ".tmp"
	if err := os.WriteFile(tmp, []byte(path+"\n"), 0o640); err != nil {
		return err
	}
	return os.Rename(tmp, target)
}

// Info is het resultaat van een schijfcontrole.
type Info struct {
	Path  string
	Free  uint64
	Total uint64
	// Reserved zijn blokken die alleen root mag gebruiken (tune2fs -m).
	Reserved uint64
}

// Inspect eist een absoluut pad dat bestaat, een map is, beschrijfbaar is
// en minstens MinFreeBytes vrij heeft. Bij een te volle of niet beschrijfbare
// map zitten Free en Total alsnog in het resultaat.
func Inspect(path string) (Info, error) {
	path = strings.TrimSpace(path)
	if path == "" {
		return Info{}, i18n.E("err.pathMissing")
	}
	if strings.ContainsAny(path, "\r\n") {
		return Info{}, i18n.E("err.pathNewline")
	}
	if !filepath.IsAbs(path) {
		return Info{}, i18n.E("err.pathAbsolute")
	}
	path = filepath.Clean(path)
	info := Info{Path: path}
	st, err := os.Stat(path)
	if err != nil {
		if errors.Is(err, os.ErrNotExist) {
			return info, i18n.E("err.pathAbsent")
		}
		return info, i18n.E("err.pathRead", err.Error())
	}
	if !st.IsDir() {
		return info, i18n.E("err.pathDir")
	}
	var stat syscall.Statfs_t
	if err := syscall.Statfs(path, &stat); err != nil {
		return info, i18n.E("err.pathFree", err.Error())
	}
	info.Free = uint64(stat.Bavail) * uint64(stat.Bsize)
	info.Total = uint64(stat.Blocks) * uint64(stat.Bsize)
	if stat.Bfree > stat.Bavail {
		info.Reserved = (uint64(stat.Bfree) - uint64(stat.Bavail)) * uint64(stat.Bsize)
	}
	probe := filepath.Join(path, ".bluegit-write-test")
	f, err := os.OpenFile(probe, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
	if err != nil {
		return info, i18n.E("err.pathWrite")
	}
	_ = f.Close()
	_ = os.Remove(probe)
	if info.Free < MinFreeBytes {
		return info, i18n.E("err.pathSpace", Format(info.Free), Format(MinFreeBytes))
	}
	return info, nil
}

// Used is de bezette ruimte: totaal min vrij min gereserveerd.
// Gereserveerde blokken tellen dus niet als data.
func (i Info) Used() uint64 {
	if i.Free+i.Reserved >= i.Total {
		return 0
	}
	return i.Total - i.Free - i.Reserved
}

// Percent rondt used/total af op een heel percentage.
// Een leeg totaal is 0. Meer dan vol blijft 100.
func Percent(used, total uint64) int {
	if total == 0 {
		return 0
	}
	if used > total {
		used = total
	}
	return int((used*100 + total/2) / total)
}

// DirSize telt de schijnbare grootte van path, recursief.
// Symlinks worden niet gevolgd. Een afgelopen context stopt de wandeling
// en geeft terug wat al geteld is, samen met ctx.Err().
func DirSize(ctx context.Context, root string) (uint64, error) {
	var total uint64
	err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error {
		if ctx.Err() != nil {
			return ctx.Err()
		}
		if err != nil {
			if path == root {
				return err
			}
			return nil
		}
		info, ierr := d.Info()
		if ierr != nil {
			return nil
		}
		if info.Mode()&os.ModeSymlink != 0 {
			return nil
		}
		total += uint64(info.Size())
		return nil
	})
	if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
		return total, err
	}
	return total, err
}

// Format maakt een korte grootte, bijvoorbeeld "1.5 GiB".
func Format(n uint64) string {
	const unit = 1024
	if n < unit {
		return fmt.Sprintf("%d B", n)
	}
	div := uint64(unit)
	exp := 0
	for n/div >= unit && exp < 4 {
		div *= unit
		exp++
	}
	value := float64(n) / float64(div)
	return fmt.Sprintf("%.1f %ciB", value, "KMGT"[exp])
}
