veza/veza-backend-api/internal/services/dmca_service.go

package services

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"time"

	"github.com/google/uuid"
	"go.uber.org/zap"
	"gorm.io/gorm"

	"veza-backend-api/internal/models"
)

// Sentinels — callers branch on these.
var (
	ErrDmcaNotFound      = errors.New("dmca notice not found")
	ErrDmcaInvalidStatus = errors.New("dmca notice not in pending state")
	ErrDmcaTrackMissing  = errors.New("track referenced by dmca notice no longer exists")
)

// DmcaService is the persistence + state-machine layer for DMCA
// notices. It is intentionally thin — most policy lives in the
// handler (validation, rate limit) and the migration (CHECK constraint
// on status). What this service owns :
//
//   - inserting new pending notices,
//   - listing the pending queue (paginated),
//   - transitioning to takedown (also flips the track flags),
//   - transitioning to dismissed,
//   - appending audit log entries.
type DmcaService struct {
	db     *gorm.DB
	logger *zap.Logger
}

// NewDmcaService wires the service. Pass the primary DB only — read
// replica isn't relevant here (admin queue, low volume).
func NewDmcaService(db *gorm.DB, logger *zap.Logger) *DmcaService {
	if logger == nil {
		logger = zap.NewNop()
	}
	return &DmcaService{db: db, logger: logger}
}

// CreateNoticeInput captures the fields a public submission carries.
// The handler validates upstream ; this struct trusts its input.
type CreateNoticeInput struct {
	ClaimantEmail     string
	ClaimantName      string
	ClaimantAddress   string
	WorkDescription   string
	InfringingTrackID *uuid.UUID
	IPAddress         string
}

// CreateNotice persists a pending DMCA notice + seeds the audit log
// with a "submitted" entry that records the source IP.
func (s *DmcaService) CreateNotice(ctx context.Context, in CreateNoticeInput) (*models.DmcaNotice, error) {
	now := time.Now()
	auditLog := []models.DmcaAuditEntry{{
		Timestamp: now,
		Action:    "submitted",
		Note:      "submitted from " + in.IPAddress,
	}}
	auditJSON, err := json.Marshal(auditLog)
	if err != nil {
		return nil, fmt.Errorf("marshal audit log: %w", err)
	}

	notice := &models.DmcaNotice{
		Status:            models.DmcaStatusPending,
		ClaimantEmail:     in.ClaimantEmail,
		ClaimantName:      in.ClaimantName,
		ClaimantAddress:   in.ClaimantAddress,
		WorkDescription:   in.WorkDescription,
		InfringingTrackID: in.InfringingTrackID,
		SwornStatementAt:  now,
		AuditLog:          auditJSON,
	}

	if err := s.db.WithContext(ctx).Create(notice).Error; err != nil {
		return nil, fmt.Errorf("insert dmca notice: %w", err)
	}
	return notice, nil
}

// ListPending returns the pending queue oldest-first. `page` is
// 1-based ; `limit` is clamped to [1, 100].
func (s *DmcaService) ListPending(ctx context.Context, page, limit int) ([]models.DmcaNotice, int64, error) {
	if page < 1 {
		page = 1
	}
	if limit < 1 {
		limit = 20
	}
	if limit > 100 {
		limit = 100
	}

	var notices []models.DmcaNotice
	var total int64
	q := s.db.WithContext(ctx).Model(&models.DmcaNotice{}).Where("status = ?", models.DmcaStatusPending)

	if err := q.Count(&total).Error; err != nil {
		return nil, 0, fmt.Errorf("count dmca pending: %w", err)
	}
	if err := q.Order("created_at ASC").
		Offset((page - 1) * limit).Limit(limit).
		Find(&notices).Error; err != nil {
		return nil, 0, fmt.Errorf("list dmca pending: %w", err)
	}
	return notices, total, nil
}

// Takedown atomically transitions a notice from pending → takedown,
// flips the referenced track to is_public=false + dmca_blocked=true,
// and appends an audit_log entry. Returns ErrDmcaInvalidStatus if
// the notice is not in pending state, ErrDmcaTrackMissing if the
// referenced track is gone (admin must dismiss instead).
func (s *DmcaService) Takedown(ctx context.Context, noticeID, adminID uuid.UUID, note string) (*models.DmcaNotice, error) {
	var updated *models.DmcaNotice
	err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var notice models.DmcaNotice
		if err := tx.Where("id = ?", noticeID).First(&notice).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return ErrDmcaNotFound
			}
			return err
		}
		if notice.Status != models.DmcaStatusPending {
			return ErrDmcaInvalidStatus
		}
		if notice.InfringingTrackID == nil {
			return ErrDmcaTrackMissing
		}

		// Flip the track flags.
		res := tx.Model(&models.Track{}).
			Where("id = ?", *notice.InfringingTrackID).
			Updates(map[string]interface{}{
				"is_public":    false,
				"dmca_blocked": true,
			})
		if res.Error != nil {
			return fmt.Errorf("flip track to dmca_blocked: %w", res.Error)
		}
		if res.RowsAffected == 0 {
			return ErrDmcaTrackMissing
		}

		// Update the notice + append audit log.
		now := time.Now()
		entries, err := appendAudit(notice.AuditLog, models.DmcaAuditEntry{
			Timestamp: now,
			ActorID:   &adminID,
			Action:    "takedown",
			Note:      note,
		})
		if err != nil {
			return err
		}
		notice.Status = models.DmcaStatusTakedown
		notice.TakedownAt = &now
		notice.AuditLog = entries
		if err := tx.Save(&notice).Error; err != nil {
			return fmt.Errorf("update dmca notice: %w", err)
		}
		updated = &notice
		return nil
	})
	if err != nil {
		return nil, err
	}
	return updated, nil
}

// Dismiss flips a pending notice to dismissed (admin rejected the
// claim — fraud, insufficient grounds, etc.). Track flags untouched.
func (s *DmcaService) Dismiss(ctx context.Context, noticeID, adminID uuid.UUID, note string) (*models.DmcaNotice, error) {
	var updated *models.DmcaNotice
	err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var notice models.DmcaNotice
		if err := tx.Where("id = ?", noticeID).First(&notice).Error; err != nil {
			if errors.Is(err, gorm.ErrRecordNotFound) {
				return ErrDmcaNotFound
			}
			return err
		}
		if notice.Status != models.DmcaStatusPending {
			return ErrDmcaInvalidStatus
		}
		now := time.Now()
		entries, err := appendAudit(notice.AuditLog, models.DmcaAuditEntry{
			Timestamp: now,
			ActorID:   &adminID,
			Action:    "dismissed",
			Note:      note,
		})
		if err != nil {
			return err
		}
		notice.Status = models.DmcaStatusDismissed
		notice.AuditLog = entries
		if err := tx.Save(&notice).Error; err != nil {
			return fmt.Errorf("update dmca notice: %w", err)
		}
		updated = &notice
		return nil
	})
	if err != nil {
		return nil, err
	}
	return updated, nil
}

// appendAudit decodes the existing JSONB array, appends the new
// entry, and re-encodes. Keeps the audit_log column self-contained
// without joining audit_logs for the common "show me this notice's
// trail" admin lookup.
func appendAudit(existing json.RawMessage, entry models.DmcaAuditEntry) (json.RawMessage, error) {
	var entries []models.DmcaAuditEntry
	if len(existing) > 0 {
		if err := json.Unmarshal(existing, &entries); err != nil {
			return nil, fmt.Errorf("decode existing audit_log: %w", err)
		}
	}
	entries = append(entries, entry)
	return json.Marshal(entries)
}