// Package archive maakt, bewaart, ruimt op en pakt archieven uit.
//
// Een archief is een tar.gz (PAX, mtimes in milliseconden) van de kopie met
// logische paden (state/…, data/…), precies wat BlueGit bij een restore
// aanneemt. Naam: bluegit-YYYYMMDD-HHMMSS.tar.gz in UTC.
package archive

import (
	"archive/tar"
	"compress/gzip"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"regexp"
	"sort"
	"strings"
	"time"

	"gitlab.com/Timfa/bluegit/internal/backupserver/protocol"
)

var nameRE = regexp.MustCompile(`^bluegit-\d{8}-\d{6}(-\d{1,3})?\.tar\.gz$`)

// ValidName zegt of name een archiefnaam is (geen pad, geen ..).
func ValidName(name string) bool { return nameRE.MatchString(name) }

// Archive is één archief op schijf.
type Archive struct {
	Name      string    `json:"name"`
	CreatedAt time.Time `json:"created_at"`
	Size      int64     `json:"size"`
}

// Store is de map met archieven.
type Store struct {
	Dir string
	// Free geeft de vrije bytes op het bestandssysteem van Dir. Tests
	// zetten een nep-versie; nil gebruikt statfs.
	Free func(dir string) (uint64, error)
}

func (s *Store) free() (uint64, error) {
	if s.Free != nil {
		return s.Free(s.Dir)
	}
	return FreeBytes(s.Dir)
}

// List geeft de archieven, nieuwste eerst.
func (s *Store) List() ([]Archive, error) {
	ents, err := os.ReadDir(s.Dir)
	if errors.Is(err, os.ErrNotExist) {
		return []Archive{}, nil
	}
	if err != nil {
		return nil, err
	}
	out := []Archive{}
	for _, e := range ents {
		if e.IsDir() || !ValidName(e.Name()) {
			continue
		}
		fi, err := e.Info()
		if err != nil {
			continue
		}
		out = append(out, Archive{Name: e.Name(), CreatedAt: createdAt(e.Name(), fi), Size: fi.Size()})
	}
	sort.Slice(out, func(i, j int) bool {
		if out[i].CreatedAt.Equal(out[j].CreatedAt) {
			return out[i].Name > out[j].Name
		}
		return out[i].CreatedAt.After(out[j].CreatedAt)
	})
	return out, nil
}

// createdAt neemt de mtime: die is gelijk aan de naam, maar tests en een
// beheerder kunnen hem verzetten om de bewaartermijn te testen.
func createdAt(name string, fi fs.FileInfo) time.Time {
	return fi.ModTime().UTC()
}

// Path geeft het pad van een bestaand archief.
func (s *Store) Path(name string) (string, error) {
	if !ValidName(name) {
		return "", errors.New("ongeldige archiefnaam")
	}
	p := filepath.Join(s.Dir, name)
	if _, err := os.Stat(p); err != nil {
		return "", fmt.Errorf("archief %s bestaat niet", name)
	}
	return p, nil
}

// Delete verwijdert één archief.
func (s *Store) Delete(name string) error {
	p, err := s.Path(name)
	if err != nil {
		return err
	}
	return os.Remove(p)
}

// DeleteAll verwijdert alle archieven.
func (s *Store) DeleteAll() error {
	list, err := s.List()
	if err != nil {
		return err
	}
	for _, a := range list {
		if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
			return err
		}
	}
	return nil
}

// Create schrijft een nieuw archief van mirrorDir. needBytes is een
// schatting van de grootte; is er te weinig ruimte, dan gaan eerst oude
// archieven weg (het nieuwste blijft).
func (s *Store) Create(mirrorDir string, now time.Time, needBytes int64, minFree uint64) (Archive, []string, error) {
	if err := os.MkdirAll(s.Dir, 0o750); err != nil {
		return Archive{}, nil, err
	}
	var removed []string
	for {
		free, err := s.free()
		if err != nil || free >= uint64(needBytes)+minFree {
			break
		}
		// Het nieuwe archief wordt het nieuwste; daarvoor mag ook het
		// laatste oude weg. De draaiende kopie blijft altijd staan.
		name, ok, err := s.removeOldest(0)
		if err != nil {
			return Archive{}, removed, err
		}
		if !ok {
			return Archive{}, removed, fmt.Errorf("te weinig schijfruimte voor een archief (%d MB vrij, %d MB nodig)", free>>20, (uint64(needBytes)+minFree)>>20)
		}
		removed = append(removed, name)
	}
	base := "bluegit-" + now.UTC().Format("20060102-150405")
	name := base + ".tar.gz"
	for i := 1; ; i++ {
		if _, err := os.Stat(filepath.Join(s.Dir, name)); errors.Is(err, os.ErrNotExist) {
			break
		}
		name = fmt.Sprintf("%s-%d.tar.gz", base, i)
	}
	tmp := filepath.Join(s.Dir, "."+name+".partial")
	f, err := os.OpenFile(tmp, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o640)
	if err != nil {
		return Archive{}, removed, err
	}
	if err := WriteTarGz(f, mirrorDir); err != nil {
		f.Close()
		os.Remove(tmp)
		return Archive{}, removed, err
	}
	if err := f.Sync(); err != nil {
		f.Close()
		os.Remove(tmp)
		return Archive{}, removed, err
	}
	if err := f.Close(); err != nil {
		os.Remove(tmp)
		return Archive{}, removed, err
	}
	final := filepath.Join(s.Dir, name)
	if err := os.Rename(tmp, final); err != nil {
		os.Remove(tmp)
		return Archive{}, removed, err
	}
	_ = os.Chtimes(final, now, now)
	fi, _ := os.Stat(final)
	return Archive{Name: name, CreatedAt: now.UTC(), Size: fi.Size()}, removed, nil
}

// removeOldest verwijdert het oudste archief zolang er meer dan keep zijn.
func (s *Store) removeOldest(keep int) (string, bool, error) {
	list, err := s.List()
	if err != nil {
		return "", false, err
	}
	if len(list) <= keep {
		return "", false, nil
	}
	old := list[len(list)-1]
	if err := os.Remove(filepath.Join(s.Dir, old.Name)); err != nil {
		return "", false, err
	}
	return old.Name, true, nil
}

// Prune verwijdert archieven ouder dan retentionDays (0 = niet op leeftijd)
// en daarna de oudste zolang er minder dan minFree bytes vrij is. Het
// nieuwste archief blijft altijd staan.
func (s *Store) Prune(now time.Time, retentionDays int, minFree uint64) ([]string, error) {
	var removed []string
	list, err := s.List()
	if err != nil {
		return nil, err
	}
	if retentionDays > 0 {
		cut := now.Add(-time.Duration(retentionDays) * 24 * time.Hour)
		for i, a := range list {
			if i == 0 || !a.CreatedAt.Before(cut) {
				continue
			}
			if err := os.Remove(filepath.Join(s.Dir, a.Name)); err != nil {
				return removed, err
			}
			removed = append(removed, a.Name)
		}
	}
	for {
		free, err := s.free()
		if err != nil || free >= minFree {
			break
		}
		name, ok, err := s.removeOldest(1)
		if err != nil {
			return removed, err
		}
		if !ok {
			break
		}
		removed = append(removed, name)
	}
	return removed, nil
}

// WriteTarGz schrijft dir als tar.gz met logische paden naar w.
func WriteTarGz(w io.Writer, dir string) error {
	gz, _ := gzip.NewWriterLevel(w, gzip.DefaultCompression)
	tw := tar.NewWriter(gz)
	var paths []string
	err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
		if err != nil {
			if errors.Is(err, fs.ErrNotExist) && p == dir {
				return fs.SkipDir
			}
			return err
		}
		if d.Type().IsRegular() {
			paths = append(paths, p)
		}
		return nil
	})
	if err != nil {
		return err
	}
	sort.Strings(paths)
	for _, p := range paths {
		rel, _ := filepath.Rel(dir, p)
		logical := filepath.ToSlash(rel)
		if _, ok := protocol.CleanLogical(logical); !ok {
			continue
		}
		if err := addFile(tw, p, logical); err != nil {
			return err
		}
	}
	if err := tw.Close(); err != nil {
		return err
	}
	return gz.Close()
}

func addFile(tw *tar.Writer, p, logical string) error {
	f, err := os.Open(p)
	if err != nil {
		return err
	}
	defer f.Close()
	fi, err := f.Stat()
	if err != nil {
		return err
	}
	h := &tar.Header{
		Name: logical, Mode: int64(fi.Mode().Perm()), Size: fi.Size(), Typeflag: tar.TypeReg,
		ModTime: fi.ModTime(), Format: tar.FormatPAX,
	}
	if err := tw.WriteHeader(h); err != nil {
		return err
	}
	_, err = io.CopyN(tw, f, fi.Size())
	return err
}

// Extract pakt archief src uit in dst (dat nog niet mag bestaan). Alleen
// gewone bestanden met geldige logische paden.
func Extract(src, dst string) error {
	f, err := os.Open(src)
	if err != nil {
		return err
	}
	defer f.Close()
	return ExtractReader(f, dst)
}

// ExtractReader is Extract vanaf een stroom.
func ExtractReader(r io.Reader, dst string) error {
	if err := os.MkdirAll(dst, 0o750); err != nil {
		return err
	}
	gz, err := gzip.NewReader(r)
	if err != nil {
		return err
	}
	tr := tar.NewReader(gz)
	for {
		h, err := tr.Next()
		if err == io.EOF {
			return nil
		}
		if err != nil {
			return err
		}
		if h.Typeflag == tar.TypeDir {
			continue
		}
		logical, ok := protocol.CleanLogical(strings.TrimPrefix(h.Name, "./"))
		if h.Typeflag != tar.TypeReg || !ok {
			return fmt.Errorf("ongeldig item in archief: %q", h.Name)
		}
		out := filepath.Join(dst, filepath.FromSlash(logical))
		if err := os.MkdirAll(filepath.Dir(out), 0o750); err != nil {
			return err
		}
		mode := os.FileMode(h.Mode).Perm()&0o755 | 0o600
		w, err := os.OpenFile(out, os.O_CREATE|os.O_EXCL|os.O_WRONLY, mode)
		if err != nil {
			return err
		}
		if _, err := io.Copy(w, tr); err != nil {
			w.Close()
			return err
		}
		if err := w.Close(); err != nil {
			return err
		}
		_ = os.Chtimes(out, h.ModTime, h.ModTime)
	}
}
