package jobs

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

	"ddc/internal/diskspace"
	"ddc/internal/explain"
	"ddc/internal/extract"
	"ddc/internal/files"
)

const maxArchiveEntries = 100000

var errNotArchive = errors.New("selected file is not a supported archive")

func (manager *Manager) Extract(id, relativePath string) error {
	job, err := manager.lookup(id)
	if err != nil {
		return err
	}

	archivePath, err := files.ResolveInside(job.directory, relativePath)
	if err != nil {
		return invalid(err)
	}
	info, err := os.Stat(archivePath)
	if err != nil || !info.Mode().IsRegular() || !extract.IsArchive(archivePath) {
		return invalid(errNotArchive)
	}

	if !job.begin(StatusExtracting, StatusReady) {
		return ErrJobBusy
	}
	manager.runInBackground(job, "extraction", func() {
		if _, err := manager.extractArchive(job, archivePath); err != nil {
			manager.failExtraction(job, err)
			return
		}
		job.setStatus(StatusReady, "")
	})
	return nil
}

func (manager *Manager) extractArchive(job *Job, archivePath string) (string, error) {
	available, err := diskspace.Available(job.directory)
	if err != nil {
		return "", err
	}
	limit := available - manager.reservedBytes()
	if limit <= 0 {
		return "", diskspace.ErrInsufficientSpace
	}

	directoryName := extract.DirectoryName(filepath.Base(archivePath))
	destination := files.UniquePath(filepath.Join(filepath.Dir(archivePath), directoryName))
	limits := extract.Limits{MaxBytes: limit, MaxEntries: maxArchiveEntries}

	job.resetProgress()
	started := time.Now()
	job.logger().Info("extraction started", "archive", filepath.Base(archivePath))
	if err := extract.Archive(job.jobContext, archivePath, destination, limits, job); err != nil {
		return "", err
	}
	job.logger().Info("extraction finished",
		"archive", filepath.Base(archivePath),
		"folder", filepath.Base(destination),
		"duration", time.Since(started).Round(time.Second).String(),
	)
	if err := os.Remove(archivePath); err != nil {
		job.logger().Warn("could not remove archive after extraction", "archive", archivePath, "error", err)
	}
	return destination, nil
}

func (manager *Manager) failExtraction(job *Job, err error) {
	if job.jobContext.Err() != nil {
		job.setStatus(StatusCancelled, "")
		return
	}
	job.logger().Error("extraction failed", "error", err)
	job.setStatus(StatusReady, "Extraction failed: "+explain.Error(err))
}