//nolint:dupl
package private_link

import (
	"context"

	"github.com/tidbcloud/dataflow-service/app/repo"
	"github.com/tidbcloud/dataflow-service/app/repo/entity"
	"github.com/tidbcloud/pkgv2/bizerr"
	"github.com/tidbcloud/pkgv2/db"
)

type bizPrivateLinkEndpointUsageRepoImpl struct {
	dbProvider db.Provider
}

func NewBizPrivateLinkEndpointUsageRepo(dbProvider db.Provider) repo.BizPrivateLinkEndpointUsageRepo {
	return &bizPrivateLinkEndpointUsageRepoImpl{
		dbProvider: dbProvider,
	}
}

func (m *bizPrivateLinkEndpointUsageRepoImpl) Load(
	ctx context.Context, id uint64,
) (*entity.BizPrivateLinkEndpointUsage, bizerr.BizError) {
	rdb := m.dbProvider.ReadDB(ctx)
	bizPLEndpointUsage := new(entity.BizPrivateLinkEndpointUsage)
	if err := entity.NewBizPrivateLinkEndpointUsageQuerySet(rdb).
		IDEq(entity.ID(id)).One(bizPLEndpointUsage); err != nil {
		return nil, bizerr.WrapGormError(err, "load biz_private_link_endpoint_usage error")
	}
	return bizPLEndpointUsage, nil
}

func (m *bizPrivateLinkEndpointUsageRepoImpl) List(
	ctx context.Context, ops ...repo.BizPrivateLinkEndpointUsageFilterOP,
) ([]entity.BizPrivateLinkEndpointUsage, bizerr.BizError) {
	rdb := m.dbProvider.ReadDB(ctx)
	qs := entity.NewBizPrivateLinkEndpointUsageQuerySet(rdb)
	for _, op := range ops {
		qs = op(qs)
	}

	var bizPLEndpointUsages []entity.BizPrivateLinkEndpointUsage
	if err := qs.All(&bizPLEndpointUsages); err != nil {
		return nil, bizerr.WrapGormError(err, "list biz_private_link_endpoint_usages error")
	}
	return bizPLEndpointUsages, nil
}

func (m *bizPrivateLinkEndpointUsageRepoImpl) Count(
	ctx context.Context, ops ...repo.BizPrivateLinkEndpointUsageFilterOP,
) (int64, bizerr.BizError) {
	rdb := m.dbProvider.ReadDB(ctx)
	qs := entity.NewBizPrivateLinkEndpointUsageQuerySet(rdb)
	for _, op := range ops {
		qs = op(qs)
	}

	total, err := qs.Count()
	if err != nil {
		return 0, bizerr.WrapGormError(err, "count biz_private_link_endpoint_usages error")
	}
	return total, nil
}

func (m *bizPrivateLinkEndpointUsageRepoImpl) Save(
	ctx context.Context, endpointUsage *entity.BizPrivateLinkEndpointUsage,
) bizerr.BizError {
	wdb := m.dbProvider.WriteDB(ctx)
	if err := entity.SaveWithVersioning(wdb, endpointUsage); err != nil {
		return err.Chain("save biz_private_link_endpoint_usage error")
	}
	return nil
}

func (m *bizPrivateLinkEndpointUsageRepoImpl) Delete(ctx context.Context, id uint64) bizerr.BizError {
	wdb := m.dbProvider.WriteDB(ctx)
	if err := wdb.Delete(&entity.BizPrivateLinkEndpointUsage{}, id).Error; err != nil {
		return bizerr.WrapGormError(err, "delete biz_private_link_endpoint_usage error")
	}
	return nil
}