package like

import (
	"context"
	"tercul/internal/app/analytics"
	"tercul/internal/domain"
)

// LikeCommands contains the command handlers for the like aggregate.
type LikeCommands struct {
	repo         domain.LikeRepository
	analyticsSvc analytics.Service
}

// NewLikeCommands creates a new LikeCommands handler.
func NewLikeCommands(repo domain.LikeRepository, analyticsSvc analytics.Service) *LikeCommands {
	return &LikeCommands{
		repo:         repo,
		analyticsSvc: analyticsSvc,
	}
}

// CreateLikeInput represents the input for creating a new like.
type CreateLikeInput struct {
	UserID        uint
	WorkID        *uint
	TranslationID *uint
	CommentID     *uint
}

// CreateLike creates a new like and increments the relevant counter.
func (c *LikeCommands) CreateLike(ctx context.Context, input CreateLikeInput) (*domain.Like, error) {
	like := &domain.Like{
		UserID:        input.UserID,
		WorkID:        input.WorkID,
		TranslationID: input.TranslationID,
		CommentID:     input.CommentID,
	}
	err := c.repo.Create(ctx, like)
	if err != nil {
		return nil, err
	}

	// After creating the like, increment the appropriate counter.
	if c.analyticsSvc != nil {
		if input.WorkID != nil {
			go c.analyticsSvc.IncrementWorkLikes(context.Background(), *input.WorkID)
		}
		if input.TranslationID != nil {
			go c.analyticsSvc.IncrementTranslationLikes(context.Background(), *input.TranslationID)
		}
		// Assuming there's a counter for comment likes, which is a reasonable feature to add.
		// if input.CommentID != nil {
		// 	go c.analyticsSvc.IncrementCommentLikes(context.Background(), *input.CommentID)
		// }
	}

	return like, nil
}

// DeleteLike deletes a like by ID.
func (c *LikeCommands) DeleteLike(ctx context.Context, id uint) error {
	return c.repo.Delete(ctx, id)
}