ReSendit/internal/file/zip.go

package file

import (
	"archive/zip"
	"crypto/rand"
	"errors"
	"fmt"
	"io"
	"math/big"
	"mime/multipart"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/google/uuid"
)

func safeZipName(name string) string {
	name = filepath.Base(name)
	name = strings.ReplaceAll(name, "\\", "_")
	name = strings.ReplaceAll(name, "/", "_")
	name = strings.TrimSpace(name)
	if name == "" || name == "." {
		return "file"
	}
	return name
}

func dedupeName(name string, seen map[string]int) string {
	if _, ok := seen[name]; !ok {
		seen[name] = 1
		return name
	}
	seen[name]++
	ext := filepath.Ext(name)
	base := strings.TrimSuffix(name, ext)
	return fmt.Sprintf("%s (%d)%s", base, seen[name], ext)
}

func randIndex(n int) int {
	if n <= 0 {
		return 0
	}
	x, err := rand.Int(rand.Reader, big.NewInt(int64(n)))
	if err != nil {
		return 0
	}
	return int(x.Int64())
}

func cuteZipName(fileCount int) string {
	adjectives := []string{
		"Cool", "Super", "Hot", "Spicy", "Sneaky", "Sleepy", "Tiny", "Mega", "Cosmic", "Silly",
		"Cursed", "Blessed", "Wiggly", "Giga", "Chonky", "Shiny", "Angry", "Happy", "Soft", "Turbo",
	}
	things := []string{
		"Potato", "Griefers", "Raccoons", "Pigeons", "Wizards", "Ninjas", "Pickles", "Dragons", "Goblins", "Burgers",
		"Pancakes", "Hamsters", "Bananas", "Comets", "Robots", "Cats", "Kiwis", "Frogs", "Cupcakes", "Sprites",
	}
	verbs := []string{
		"Zoom", "Bonk", "Yeet", "Vibe", "Hack", "Spark", "Bounce", "Nibble", "Smuggle", "Cook",
	}

	a := adjectives[randIndex(len(adjectives))]
	v := verbs[randIndex(len(verbs))]
	t := things[randIndex(len(things))]
	return fmt.Sprintf("%d%s%s%s.zip", fileCount, a, v, t)
}

// UploadBundle zips multiple uploaded files into a single .zip stored on disk and tracked as one FileRecord.
func (s *Service) UploadBundle(files []*multipart.FileHeader, deleteAfterDownload bool, expiresAfter time.Duration) (*FileRecord, error) {
	if len(files) == 0 {
		return nil, errors.New("no files")
	}
	if len(files) > 10 {
		return nil, errors.New("too many files (max 10)")
	}

	folderID := uuid.NewString()
	folderPath := filepath.Join(s.storageDir, folderID)
	if err := os.MkdirAll(folderPath, os.ModePerm); err != nil {
		return nil, err
	}

	zipDiskName := uuid.NewString() + ".zip"
	zipPath := filepath.Join(folderPath, zipDiskName)

	out, err := os.Create(zipPath)
	if err != nil {
		return nil, err
	}
	defer func() {
		_ = out.Close()
		if err != nil {
			_ = os.Remove(zipPath)
		}
	}()

	zw := zip.NewWriter(out)
	defer func() { _ = zw.Close() }()

	seen := map[string]int{}
	for _, fh := range files {
		rc, openErr := fh.Open()
		if openErr != nil {
			err = openErr
			return nil, openErr
		}

		name := dedupeName(safeZipName(fh.Filename), seen)
		h, _ := zip.FileInfoHeader(dummyFileInfo{name: name, size: fh.Size, mod: time.Now()})
		h.Name = name
		h.Method = zip.Deflate

		w, createErr := zw.CreateHeader(h)
		if createErr != nil {
			_ = rc.Close()
			err = createErr
			return nil, createErr
		}

		if _, copyErr := io.Copy(w, rc); copyErr != nil {
			_ = rc.Close()
			err = copyErr
			return nil, copyErr
		}
		_ = rc.Close()
	}

	if closeErr := zw.Close(); closeErr != nil {
		err = closeErr
		return nil, closeErr
	}
	if closeErr := out.Close(); closeErr != nil {
		err = closeErr
		return nil, closeErr
	}

	zipDisplayName := cuteZipName(len(files))

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

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

	return f, nil
}

func fileSize(path string) int64 {
	st, err := os.Stat(path)
	if err != nil {
		return 0
	}
	return st.Size()
}

// dummyFileInfo provides minimal os.FileInfo for zip headers.
// This avoids relying on the underlying uploaded file having a real modtime.
// (zip.Writer can work without this too, but headers look nicer.)
type dummyFileInfo struct {
	name string
	size int64
	mod  time.Time
}

func (d dummyFileInfo) Name() string       { return d.name }
func (d dummyFileInfo) Size() int64        { return d.size }
func (d dummyFileInfo) Mode() os.FileMode  { return 0o644 }
func (d dummyFileInfo) ModTime() time.Time { return d.mod }
func (d dummyFileInfo) IsDir() bool        { return false }
func (d dummyFileInfo) Sys() any           { return nil }