ReSendit/internal/file/service.go

package file

import (
	"io"
	"os"
	"path/filepath"
	"sort"
	"time"

	"github.com/google/uuid"
	"github.com/shirou/gopsutil/v3/disk"
)

type Service struct {
	repo       *Repository
	storageDir string
}

func NewService(r *Repository, storageDir string) *Service {
	if _, err := os.Stat(storageDir); os.IsNotExist(err) {
		os.MkdirAll(storageDir, os.ModePerm)
	}

	return &Service{repo: r, storageDir: storageDir}
}

func (s *Service) UploadFile(filename string, data io.Reader, deleteAfterDownload bool, expiresAfter time.Duration) (*FileRecord, error) {
	folderID := uuid.NewString()
	folderPath := s.storageDir + "/" + folderID

	if err := os.MkdirAll(folderPath, os.ModePerm); err != nil {
		return nil, err
	}

	safeName := uuid.NewString() + filepath.Ext(filename)
	path := filepath.Join(folderPath, safeName)

	out, err := os.Create(path)
	if err != nil {
		return nil, err
	}
	defer out.Close()

	size, err := io.Copy(out, data)
	if err != nil {
		return nil, err
	}

	f := &FileRecord{
		ID:                  folderID,
		DeletionID:          uuid.NewString(),
		ViewID:              uuid.NewString(),
		Filename:            filename,
		Path:                path,
		Size:                size,
		CreatedAt:           time.Now(),
		ExpiresAt:           time.Now().Add(expiresAfter),
		DeleteAfterDownload: deleteAfterDownload,
	}

	if err := s.repo.Create(f); err != nil {
		return nil, err
	}

	return f, nil
}

// DownloadFile Download a file
func (s *Service) DownloadFile(id string) (*FileRecord, error) {
	f, err := s.repo.GetByID(id)
	if err != nil {
		return nil, err
	}

	if f.Deleted || time.Now().After(f.ExpiresAt) {
		return nil, ErrFileNotFound
	}

	_ = s.repo.IncrementDownload(f)

	if f.DeleteAfterDownload {
		_ = s.repo.MarkDeleted(f)
	}

	return f, nil
}

func (s *Service) DeleteFileByID(id string) (*FileRecord, error) {
	f, err := s.repo.GetByID(id)
	if err != nil {
		return nil, err
	}

	if f.Deleted {
		return nil, ErrFileNotFound
	}

	if err := s.repo.MarkDeleted(f); err != nil {
		return nil, err
	}

	return f, nil
}

func (s *Service) DeleteFileByDeletionID(delID string) (*FileRecord, error) {
	f, err := s.repo.GetByDeletionID(delID)
	if err != nil {
		return nil, err
	}

	if f.Deleted {
		return nil, ErrFileNotFound
	}

	if err := s.repo.MarkDeleted(f); err != nil {
		return nil, err
	}

	return f, nil
}

func (s *Service) ForceDelete(id string) (*FileRecord, error) {
	f, err := s.repo.GetByID(id)
	if err != nil {
		return nil, err
	}

	if err := os.RemoveAll(s.storageDir + "/" + f.ID); err != nil {
		return nil, err
	}

	if err := s.repo.Delete(f); err != nil {
		return nil, err
	}

	return f, nil
}

func (s *Service) ReinstateFile(id string) (*FileRecord, error) {
	f, err := s.repo.GetByID(id)
	if err != nil {
		return nil, err
	}

	if !f.Deleted {
		return nil, ErrFileNotFound // or just return f, nil maybe?
	}

	// Check if file actually exists on disk
	path := s.storageDir + "/" + f.ID
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return nil, ErrFileNotFound
	}

	if err := s.repo.MarkNotDeleted(f); err != nil {
		return nil, err
	}

	return f, nil
}

func (s *Service) GetPaginatedFiles(limit, offset int) ([]FileRecord, int, error) {
	return s.repo.GetPaginated(limit, offset)
}

func (s *Service) GetFileByID(id string) (*FileRecord, error) {
	return s.repo.GetByID(id)
}

func (s *Service) GetFileByDeletionID(delID string) (*FileRecord, error) {
	return s.repo.GetByDeletionID(delID)
}

func (s *Service) GetFileByViewID(viewID string) (*FileRecord, error) {
	return s.repo.GetFileByViewID(viewID)
}

func (s *Service) ImportFiles(records []ImportFileRecord) error {
	for _, r := range records {

		existing, _ := s.repo.GetByID(r.ID)
		if existing != nil {
			continue
		}

		record := &FileRecord{
			ID:                  r.ID,
			DeletionID:          r.DeletionID,
			Filename:            r.Filename,
			Path:                s.buildPath(r.ID, r.Filename),
			ExpiresAt:           r.ExpiresAt,
			DeleteAfterDownload: r.DeleteAfterDownload,
			Size:                r.Size,
			DownloadCount:       r.DownloadCount,
			Deleted:             r.Deleted,
			CreatedAt:           r.CreatedAt,
		}

		if err := s.repo.Create(record); err != nil {
			return err
		}
	}

	return nil
}

func (s *Service) buildPath(id, filename string) string {
	return s.storageDir + "/" + id + "/" + filename
}

func (s *Service) GetAllFiles() ([]FileRecord, error) {
	return s.repo.GetAll()
}

func (s *Service) GetStorageStats() (*StorageStats, error) {
	files, err := s.repo.GetAll()
	if err != nil {
		return nil, err
	}

	stats := &StorageStats{}

	var total int64
	var active, deleted int

	for _, f := range files {
		stats.TotalFiles++

		if f.Deleted {
			deleted++
		} else {
			active++
		}

		total += f.Size
	}

	stats.TotalBytes = total
	stats.ActiveFiles = active
	stats.DeletedFiles = deleted

	if stats.TotalFiles > 0 {
		stats.AverageFileSize = total / int64(stats.TotalFiles)
	}

	// Biggest files
	sort.Slice(files, func(i, j int) bool {
		return files[i].Size > files[j].Size
	})

	if len(files) > 10 {
		stats.LargestFiles = files[:10]
	} else {
		stats.LargestFiles = files
	}

	usage, err := disk.Usage(s.storageDir)
	if err == nil {
		stats.DiskTotalBytes = int64(usage.Total)
		stats.DiskFreeBytes = int64(usage.Free)
		stats.DiskUsedBytes = int64(usage.Used)
	}

	// tmp chunk usage
	var tmpTotal int64
	filepath.Walk("tmp", func(path string, info os.FileInfo, err error) error {
		if err == nil && !info.IsDir() {
			tmpTotal += info.Size()
		}
		return nil
	})

	stats.TempBytes = tmpTotal

	return stats, nil
}