package mirror

import (
	"encoding/json"
	"errors"
	"os"
	"path/filepath"
	"time"

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

// Progress is het deel van de BlueGit-dataset (database, repositories,
// releases, artifacts, avatars, enz.) dat deze kopie al bij heeft en dat
// overeenkomt met het laatste manifest. De teller is in bytes, zodat een
// groot repository zwaarder weegt dan een klein bestand. Als de hele set
// 0 bytes is (of leeg), telt het aantal bestanden; 0/0 is 100%.
type Progress struct {
	Known      bool      `json:"known"`
	Percent    int       `json:"percent"`
	Syncing    bool      `json:"syncing,omitempty"`
	DoneBytes  int64     `json:"done_bytes"`
	TotalBytes int64     `json:"total_bytes"`
	DoneFiles  int       `json:"done_files"`
	TotalFiles int       `json:"total_files"`
	UpdatedAt  time.Time `json:"updated_at,omitempty"`
}

// ComputeProgress vergelijkt de index met de bestanden uit een manifest.
// files == nil betekent: nog geen manifest, voortgang onbekend.
func ComputeProgress(idx map[string]protocol.Entry, files []protocol.Entry) Progress {
	if files == nil {
		return Progress{}
	}
	if idx == nil {
		idx = map[string]protocol.Entry{}
	}
	p := Progress{Known: true, TotalFiles: len(files), UpdatedAt: time.Now().UTC()}
	for _, e := range files {
		logical, ok := protocol.CleanLogical(e.Path)
		if !ok {
			p.TotalFiles--
			continue
		}
		p.TotalBytes += e.Size
		if old, ok := idx[logical]; ok && same(old, e) {
			p.DoneFiles++
			p.DoneBytes += e.Size
		}
	}
	switch {
	case p.TotalFiles == 0:
		p.Percent = 100
	case p.DoneFiles == p.TotalFiles:
		p.Percent = 100
	case p.TotalBytes > 0:
		p.Percent = int(p.DoneBytes * 100 / p.TotalBytes)
		if p.Percent >= 100 {
			// Nog ontbrekende lege bestanden: nooit 100% tot alles er is.
			p.Percent = 99
		}
	default:
		p.Percent = p.DoneFiles * 100 / p.TotalFiles
	}
	if p.Percent < 0 {
		p.Percent = 0
	}
	return p
}

func (m *Mirror) manifestPath() string {
	return filepath.Join(filepath.Dir(m.Index), "last-manifest.json")
}

// SaveManifest bewaart het laatste manifest, zodat de voortgang tussen
// syncs en na een herstart bekend blijft.
func (m *Mirror) SaveManifest(man protocol.Manifest) error {
	b, err := json.Marshal(man)
	if err != nil {
		return err
	}
	tmp := m.manifestPath() + ".tmp"
	if err := os.WriteFile(tmp, b, 0o600); err != nil {
		return err
	}
	return os.Rename(tmp, m.manifestPath())
}

// LoadManifest leest het laatste manifest. ok is false als het ontbreekt.
func (m *Mirror) LoadManifest() (protocol.Manifest, bool, error) {
	var man protocol.Manifest
	b, err := os.ReadFile(m.manifestPath())
	if errors.Is(err, os.ErrNotExist) {
		return man, false, nil
	}
	if err != nil {
		return man, false, err
	}
	if err := json.Unmarshal(b, &man); err != nil {
		return man, false, err
	}
	return man, true, nil
}

// CurrentProgress berekent de voortgang uit de index en het laatste manifest.
func (m *Mirror) CurrentProgress() Progress {
	man, ok, err := m.LoadManifest()
	if err != nil || !ok {
		return Progress{}
	}
	idx, err := m.LoadIndex()
	if err != nil {
		idx = nil
	}
	return ComputeProgress(idx, man.Files)
}

// ClearManifest verwijdert het bewaarde manifest (na wissen of ontkoppelen).
func (m *Mirror) ClearManifest() error {
	err := os.Remove(m.manifestPath())
	if errors.Is(err, os.ErrNotExist) {
		return nil
	}
	return err
}
