Kazier/backend/service/resources.go

package service

import (
	"errors"
	"fmt"
	"io"
	"mime/multipart"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/kazier/backend/repository"
)

// ErrFileTooLarge signals an upload above MaxFileSize.
var ErrFileTooLarge = errors.New("file too large")

// FileDTO serializes exactly as mobile/api/types.ts FileDto.
type FileDTO struct {
	ID        string   `json:"id"`
	Name      string   `json:"name"`
	Size      int64    `json:"size"`
	MimeType  string   `json:"mimeType,omitempty"`
	FolderID  string   `json:"folderId,omitempty"`
	Tags      []string `json:"tags,omitempty"`
	CreatedAt string   `json:"createdAt,omitempty"`
	UpdatedAt string   `json:"updatedAt,omitempty"`
}

// FolderDTO serializes exactly as mobile/api/types.ts FolderDto.
type FolderDTO struct {
	ID       string `json:"id"`
	Name     string `json:"name"`
	ParentID string `json:"parentId,omitempty"`
}

// Resources holds the business logic for files/folders list-get-delete-upload,
// always scoped by the requesting USER (resources.user_id after 000007).
type Resources struct {
	Repo        *repository.Resources
	Repository  *repository.Repository
	UploadDir   string
	MaxFileSize int64
}

func NewResources(repo *repository.Repository, uploadDir string, maxFileSize int64) *Resources {
	return &Resources{
		Repo:        repo.Resources,
		Repository:  repo,
		UploadDir:   uploadDir,
		MaxFileSize: maxFileSize,
	}
}

func (s *Resources) ListFiles(ownerID, folderID string, page, pageSize int, sort, order string) ([]FileDTO, int, error) {
	rows, total, err := s.Repo.ListFilesVisible(ownerID, folderID, pageSize, (page-1)*pageSize, sort, order)
	if err != nil {
		return nil, 0, err
	}
	files := make([]FileDTO, 0, len(rows))
	for _, row := range rows {
		files = append(files, toFileDTO(row))
	}
	return files, total, nil
}

func (s *Resources) GetFile(ownerID, id string) (FileDTO, error) {
	row, err := s.Repo.GetFileVisible(ownerID, id)
	if err != nil {
		return FileDTO{}, err
	}
	return toFileDTO(row), nil
}

// FileOcrDTO is the payload of GET /files/:id/ocr: the server-computed OCR
// extract of the resource, readable by its owner and by grantees (viewer+).
type FileOcrDTO struct {
	Text      string `json:"text"`
	UpdatedAt string `json:"updatedAt,omitempty"`
}

// GetFileOcr returns the OCR text of a file the user can see (viewer+, own or
// shared). Absent text → Text empty ("") with 200 (the caller decides).
func (s *Resources) GetFileOcr(ownerID, id string) (FileOcrDTO, error) {
	row, err := s.Repo.GetFileVisible(ownerID, id)
	if err != nil {
		return FileOcrDTO{}, err
	}
	return FileOcrDTO{
		Text:      row.OcrText,
		UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
	}, nil
}

func (s *Resources) DeleteFile(ownerID, id string) (string, error) {
	return s.Repo.DeleteFile(ownerID, id)
}

func (s *Resources) ListRootFolders(ownerID string) ([]FolderDTO, error) {
	rows, err := s.Repo.ListRootFoldersVisible(ownerID)
	if err != nil {
		return nil, err
	}
	folders := make([]FolderDTO, 0, len(rows))
	for _, row := range rows {
		folders = append(folders, FolderDTO{ID: row.ID, Name: row.Name, ParentID: row.ParentID})
	}
	return folders, nil
}

func (s *Resources) SearchFiles(ownerID, q string, page, pageSize int) ([]FileDTO, int, error) {
	rows, total, err := s.Repo.SearchFilesVisible(ownerID, q, pageSize, (page-1)*pageSize)
	if err != nil {
		return nil, 0, err
	}
	files := make([]FileDTO, 0, len(rows))
	for _, row := range rows {
		files = append(files, toFileDTO(row))
	}
	return files, total, nil
}

// Upload persists the multipart-sourced file under UploadDir/<user> and
// records its metadata, returning the FileDTO. The physical file is removed
// if metadata persistence fails (e.g. name conflict).
//
// When resourceID is non-empty the upload TARGETS an existing file owned by
// the user (metadata-only resource from the outbox, or a previously uploaded
// file): the bytes are written under UploadDir/<user>/<resourceID>.<ext> and
// only the physical metadata (size/mime/extension) is refreshed — never a
// rename, never a move, never a duplicate row. Unknown / foreign resource →
// repo.ErrNotFound.
func (s *Resources) Upload(ownerID string, file *multipart.FileHeader, folderID, resourceID string) (FileDTO, error) {
	if file.Size > s.MaxFileSize {
		return FileDTO{}, ErrFileTooLarge
	}

	targetExisting := resourceID != ""
	if targetExisting {
		if _, err := s.Repo.GetFile(ownerID, resourceID); err != nil {
			return FileDTO{}, err
		}
	} else {
		resourceID = repository.NewID()
	}

	extension := strings.TrimPrefix(filepath.Ext(file.Filename), ".")
	destDir := filepath.Join(s.UploadDir, ownerID)
	if err := os.MkdirAll(destDir, 0o755); err != nil {
		return FileDTO{}, fmt.Errorf("create upload dir: %w", err)
	}

	destPath := filepath.Join(destDir, resourceID+"."+extension)
	if err := copyMultipart(file, destPath); err != nil {
		return FileDTO{}, err
	}

	mimeType := file.Header.Get("Content-Type")
	var err error
	if targetExisting {
		err = s.Repo.UpdatePhysical(ownerID, resourceID, file.Size, &mimeType, &extension)
	} else {
		err = s.Repo.InsertFile(ownerID, resourceID, file.Filename, folderID, file.Size, &mimeType, &extension)
	}
	if err != nil {
		_ = os.Remove(destPath)
		return FileDTO{}, err
	}

	row, err := s.Repo.GetFile(ownerID, resourceID)
	if err != nil {
		return FileDTO{}, err
	}
	return toFileDTO(row), nil
}

func copyMultipart(file *multipart.FileHeader, destPath string) error {
	src, err := file.Open()
	if err != nil {
		return fmt.Errorf("open multipart file: %w", err)
	}
	defer src.Close()

	dst, err := os.Create(destPath)
	if err != nil {
		return fmt.Errorf("create file: %w", err)
	}
	defer dst.Close()

	if _, err := io.Copy(dst, src); err != nil {
		return fmt.Errorf("copy upload: %w", err)
	}
	return nil
}

func toFileDTO(row repository.FileRow) FileDTO {
	return FileDTO{
		ID:        row.ID,
		Name:      row.Name,
		Size:      row.Size,
		MimeType:  row.MimeType,
		FolderID:  row.FolderID,
		CreatedAt: row.CreatedAt.UTC().Format(time.RFC3339),
		UpdatedAt: row.UpdatedAt.UTC().Format(time.RFC3339),
	}
}