package mirror

import (
	"context"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"os"
	"path/filepath"
	"sort"
	"strings"
	"time"

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

// Mirror is de draaiende kopie: Dir bevat de logische paden (state/…,
// data/…). Index onthoudt per bestand grootte en mtime zoals BlueGit ze
// meldde, zodat een volgende sync alleen wijzigingen ophaalt.
type Mirror struct {
	Dir   string
	Index string
}

// Stats zegt wat een sync deed.
type Stats struct {
	Files      int   `json:"files"`
	Downloaded int   `json:"downloaded"`
	Bytes      int64 `json:"bytes"`
	Deleted    int   `json:"deleted"`
	Skipped    int   `json:"skipped"`
}

// LoadIndex leest de index. Geen bestand: leeg.
func (m *Mirror) LoadIndex() (map[string]protocol.Entry, error) {
	idx := map[string]protocol.Entry{}
	b, err := os.ReadFile(m.Index)
	if errors.Is(err, os.ErrNotExist) {
		return idx, nil
	}
	if err != nil {
		return idx, err
	}
	return idx, json.Unmarshal(b, &idx)
}

func (m *Mirror) saveIndex(idx map[string]protocol.Entry) error {
	b, err := json.Marshal(idx)
	if err != nil {
		return err
	}
	tmp := m.Index + ".tmp"
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, m.Index)
}

// Empty zegt of de kopie nog niets bevat.
func (m *Mirror) Empty() bool {
	idx, err := m.LoadIndex()
	return err != nil || len(idx) == 0
}

// Size is de totale grootte volgens de index.
func (m *Mirror) Size() int64 {
	idx, _ := m.LoadIndex()
	var n int64
	for _, e := range idx {
		n += e.Size
	}
	return n
}

// Wipe verwijdert de kopie en de index.
func (m *Mirror) Wipe() error {
	if err := os.RemoveAll(m.Dir); err != nil {
		return err
	}
	err := os.Remove(m.Index)
	if errors.Is(err, os.ErrNotExist) {
		return nil
	}
	return err
}

func (m *Mirror) real(logical string) string {
	return filepath.Join(m.Dir, filepath.FromSlash(logical))
}

func same(a, b protocol.Entry) bool {
	if a.Path == protocol.DBPath || b.Path == protocol.DBPath {
		return a.SHA256 != "" && a.SHA256 == b.SHA256 && a.Size == b.Size
	}
	return a.Size == b.Size && a.MTime == b.MTime
}

// Sync haalt het manifest op en brengt de kopie gelijk: nieuwe en
// gewijzigde bestanden downloaden (begrensd), verdwenen bestanden weg.
func (m *Mirror) Sync(ctx context.Context, r *Remote) (Stats, error) {
	var st Stats
	man, err := r.Manifest(ctx)
	if err != nil {
		return st, err
	}
	idx, err := m.LoadIndex()
	if err != nil {
		idx = map[string]protocol.Entry{}
	}
	if err := os.MkdirAll(m.Dir, 0o750); err != nil {
		return st, err
	}
	tmpDir := filepath.Join(filepath.Dir(m.Dir), "tmp")
	if err := os.MkdirAll(tmpDir, 0o750); err != nil {
		return st, err
	}
	want := map[string]bool{}
	dirty := 0
	for _, e := range man.Files {
		logical, ok := protocol.CleanLogical(e.Path)
		if !ok {
			continue
		}
		want[logical] = true
		st.Files++
		if old, ok := idx[logical]; ok && same(old, e) {
			if _, err := os.Stat(m.real(logical)); err == nil {
				continue
			}
		}
		n, err := m.download(ctx, r, tmpDir, e)
		if errors.Is(err, ErrGone) {
			st.Skipped++
			want[logical] = false
			continue
		}
		if err != nil {
			_ = m.saveIndex(idx)
			return st, fmt.Errorf("%s: %w", logical, err)
		}
		idx[logical] = e
		st.Downloaded++
		st.Bytes += n
		dirty++
		if dirty >= 200 {
			_ = m.saveIndex(idx)
			dirty = 0
		}
	}
	for p := range idx {
		if !want[p] {
			_ = os.Remove(m.real(p))
			delete(idx, p)
			st.Deleted++
		}
	}
	// Ook bestanden die niet in de index stonden (een afgebroken download).
	_ = filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return nil
		}
		rel, _ := filepath.Rel(m.Dir, p)
		if _, ok := idx[filepath.ToSlash(rel)]; !ok {
			_ = os.Remove(p)
		}
		return nil
	})
	removeEmptyDirs(m.Dir)
	return st, m.saveIndex(idx)
}

func (m *Mirror) download(ctx context.Context, r *Remote, tmpDir string, e protocol.Entry) (int64, error) {
	rc, err := r.Fetch(ctx, e.Path)
	if err != nil {
		return 0, err
	}
	defer rc.Close()
	f, err := os.CreateTemp(tmpDir, "dl-*")
	if err != nil {
		return 0, err
	}
	tmp := f.Name()
	defer os.Remove(tmp)
	h := sha256.New()
	n, err := io.Copy(io.MultiWriter(f, h), rc)
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	if err != nil {
		return n, err
	}
	if e.SHA256 != "" && hex.EncodeToString(h.Sum(nil)) != e.SHA256 {
		return n, errors.New("sha256 klopt niet")
	}
	mode := os.FileMode(e.Mode).Perm()
	if mode == 0 {
		mode = 0o640
	}
	_ = os.Chmod(tmp, mode|0o600)
	dst := m.real(e.Path)
	if err := os.MkdirAll(filepath.Dir(dst), 0o750); err != nil {
		return n, err
	}
	if err := os.Rename(tmp, dst); err != nil {
		return n, err
	}
	mt := time.UnixMilli(e.MTime)
	_ = os.Chtimes(dst, mt, mt)
	return n, nil
}

func removeEmptyDirs(root string) {
	var dirs []string
	_ = filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
		if err == nil && d.IsDir() && p != root {
			dirs = append(dirs, p)
		}
		return nil
	})
	sort.Slice(dirs, func(i, j int) bool { return len(dirs[i]) > len(dirs[j]) })
	for _, d := range dirs {
		_ = os.Remove(d) // faalt als hij niet leeg is
	}
}

// RebuildIndex maakt de index opnieuw uit de bestanden zelf, na het
// uitpakken van een archief. De mtimes komen uit het archief en zijn
// dezelfde die BlueGit na het terugzetten heeft.
func (m *Mirror) RebuildIndex() error {
	idx := map[string]protocol.Entry{}
	err := filepath.WalkDir(m.Dir, func(p string, d fs.DirEntry, err error) error {
		if err != nil {
			return err
		}
		if d.IsDir() || !d.Type().IsRegular() {
			return nil
		}
		rel, _ := filepath.Rel(m.Dir, p)
		logical := filepath.ToSlash(rel)
		if _, ok := protocol.CleanLogical(logical); !ok {
			return nil
		}
		fi, err := d.Info()
		if err != nil {
			return err
		}
		e := protocol.Entry{Path: logical, Size: fi.Size(), MTime: fi.ModTime().UnixMilli(), Mode: uint32(fi.Mode().Perm())}
		if logical == protocol.DBPath {
			f, err := os.Open(p)
			if err != nil {
				return err
			}
			h := sha256.New()
			_, err = io.Copy(h, f)
			f.Close()
			if err != nil {
				return err
			}
			e.SHA256 = hex.EncodeToString(h.Sum(nil))
		}
		idx[logical] = e
		return nil
	})
	if err != nil && !errors.Is(err, fs.ErrNotExist) {
		return err
	}
	return m.saveIndex(idx)
}

// HasPath zegt of een logisch pad in de kopie staat (voor tests en status).
func (m *Mirror) HasPath(prefix string) bool {
	idx, _ := m.LoadIndex()
	for p := range idx {
		if strings.HasPrefix(p, prefix) {
			return true
		}
	}
	return false
}
