package service

import (
	"context"
	"server/internal/db"
	"server/internal/db/sqlc"
	"server/internal/model/common"
	"server/internal/model/request"
	"server/internal/pkg/dberr"
	"server/internal/pkg/errs"
)

type TagService struct {
	store *db.Store
}

func NewTagService(store *db.Store) *TagService {
	return &TagService{
		store: store,
	}
}

func (s *TagService) ListPage(ctx context.Context, p *common.Pagination) ([]sqlc.Tag, int64, error) {
	params := sqlc.ListTagsParams{
		Limit:  p.PageSize,
		Offset: (p.Page - 1) * p.PageSize,
	}

	total, err := s.store.CountTags(ctx)
	if err != nil {
		return nil, 0, err
	}

	list, err := s.store.ListTags(ctx, params)
	if err != nil {
		return nil, 0, err
	}

	return list, total, nil
}

func (s *TagService) ListAll(ctx context.Context) ([]sqlc.Tag, error) {
	return s.store.ListAllTags(ctx)
}

func (s *TagService) Create(ctx context.Context, req request.CreateTagRequest) error {
	params := sqlc.CreateTagParams{
		Name: req.Name,
		Code: req.Code,
		Sort: req.Sort,
	}

	err := s.store.CreateTag(ctx, params)
	return dberr.MapUniqueViolation(err, dberr.TagCodeKey, errs.ErrTagCodeAlreadyExists)
}

func (s *TagService) Update(ctx context.Context, id int32, req request.UpdateTagRequest) error {
	params := sqlc.UpdateTagParams{
		ID:   id,
		Name: req.Name,
		Code: req.Code,
		Sort: req.Sort,
	}
	rows, err := s.store.UpdateTag(ctx, params)
	// 先判断数据条目是否存在
	if err = dberr.MapRowsAffected(rows, err, errs.ErrTagNotFound); err != nil {
		// 再判断code是否重复
		return dberr.MapUniqueViolation(err, dberr.TagCodeKey, errs.ErrTagCodeAlreadyExists)
	}

	return nil
}

func (s *TagService) Delete(ctx context.Context, id int32) error {
	return s.store.WithTx(ctx, func(q *sqlc.Queries) error {
		// 删除中间表数据
		err := s.store.DeletePostTagByTagID(ctx, id)
		if err != nil {
			return err
		}

		// 删除标签数据
		rows, err := s.store.DeleteTag(ctx, id)
		return dberr.MapRowsAffected(rows, err, errs.ErrTagNotFound)
	})

}