package backup

/*
import (
	"fmt"
	"os"
	"testing"

	"github.com/tidbcloud/central-sdk/conf"
	"github.com/tidbcloud/central-sdk/db"
	"github.com/tidbcloud/central-sdk/db/entity"
	tenantmodel "github.com/tidbcloud/central-sdk/model/tenant"
	central "github.com/tidbcloud/central-sdk/proto/output"
	"github.com/tidbcloud/central-sdk/runtime"
	"github.com/tidbcloud/central-sdk/runtime/deployer/gardener"
	runtimemanager "github.com/tidbcloud/central-sdk/runtime/manager/fake"
	runtimeutil "github.com/tidbcloud/central-sdk/runtime/util"
	encrypt "github.com/tidbcloud/central-sdk/secret/provider/fake"
	secretprovider "github.com/tidbcloud/central-sdk/secret/provider/fake"
	"github.com/tidbcloud/central-sdk/tenant"
	testutil "github.com/tidbcloud/central-sdk/test/util"
	"github.com/pingcap/dbaas/pkg/docker_db"

	"github.com/pingcap/dbaas/pkg/secret/vault"
	"github.com/pingcap/tidb-operator/pkg/apis/pingcap/v1alpha1"
	"github.com/stretchr/testify/assert"
	"go.uber.org/zap/zaptest"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/client-go/kubernetes"
)

const (
	PROJECT = "test-backup"
)

var (
	tenantID                 int64
	logDB                    tenant.TenantLogDB
	user                     entity.User
	ZeroBackupReservedDays   = -1
	ManualBackupReservedDays = 30
	AutoBackupReservedDays   = 7
)

func init() {
	err := docker_db.TryInitCentralDB(tenant.InitTenants)
	if err != nil {
		fmt.Println("failed to initialize DB %!", err)
		os.Exit(1)
	}
	tenantID = tenant.GetAllTenantIDs()[0]

	logDB = tenant.NewLogDB(log, tenantID)
	users, err := db.ListUsers(tenant.GetDB(tenantID))
	if err != nil {
		fmt.Println("failed to list users %!", err)
		os.Exit(1)
	}
	user = users[0]
}

func GetUserContext(t *testing.T) (*UserContext, error) {
	user := &tenant.User{
		TenantID: tenantID,
		User:     user,
		CentralUser: &entity.CentralUser{
			Name:  "central-ut",
			Email: "central-ut@pingcap.com",
		},
	}
	log := zaptest.NewLogger(t)
	makeVault := func(client kubernetes.Interface) (vault.Vault, error) {
		return secretprovider.NewFakeSecretVault(client, conf.Aws)
	}
	runtimes := runtimemanager.NewFakeGardenRuntimeManager(log, PROJECT, makeVault)
	enc, err := encrypt.NewFakeSecretEncryptor(conf.Aws)
	if err != nil {
		return nil, err
	}
	model := NewModel(log, runtimes, enc, &gardener.ShootClusters{}, tenantmodel.Model{})
	return &UserContext{
		Model:         model,
		tenantAndUser: user,
		log:           log,
	}, nil
}

func GetBgContext(t *testing.T) (*BgContext, error) {
	log := zaptest.NewLogger(t)
	makeVault := func(client kubernetes.Interface) (vault.Vault, error) {
		return secretprovider.NewFakeSecretVault(client, conf.Aws)
	}
	runtimes := runtimemanager.NewFakeGardenRuntimeManager(log, PROJECT, makeVault)
	enc, err := encrypt.NewFakeSecretEncryptor(conf.Aws)
	if err != nil {
		return nil, err
	}
	model := NewModel(log, runtimes, enc, &gardener.ShootClusters{}, tenantmodel.Model{})
	bgContext, err := model.BgContext(tenantID)
	if err != nil {
		return nil, err
	}
	return &bgContext, nil
}

func TestConvertList(t *testing.T) {
	backups := []db.Backup{
		{
			Base: entity.Base{
				System: entity.System{
					ID: 1,
				},
			},
			Name:        "backup1",
			Description: &entity.TrackedText{Text: ""},
		},
		{
			Base: entity.Base{
				System: entity.System{
					ID: 2,
				},
			},
			Name:        "backup2",
			Description: &entity.TrackedText{Text: ""},
		},
		{
			Base: entity.Base{
				System: entity.System{
					ID: 3,
				},
			},
			Name:        "backup3",
			Description: &entity.TrackedText{Text: ""},
		},
	}

	backupList := []*v1alpha1.Backup{
		{
			ObjectMeta: metav1.ObjectMeta{
				Name: "backup1",
			},
			Spec: v1alpha1.BackupSpec{},
			Status: v1alpha1.BackupStatus{
				Phase: v1alpha1.BackupComplete,
			},
		},
		{
			ObjectMeta: metav1.ObjectMeta{
				Name: "backup2",
			},
			Status: v1alpha1.BackupStatus{
				Phase: v1alpha1.BackupRunning,
			},
		},
	}
	items := convertList(backups, backupList, false)
	assert.Equal(t, 3, len(items))
	items = convertList(backups, backupList, true)
	assert.Equal(t, 1, len(items))
}

func TestCleanupBackupJob(t *testing.T) {
	cluster, err := db.CreateClusterMachineType(tenant.GetCentralDB(), logDB, user, testutil.GetDefaultCluster(), int32(0))
	assert.Nil(t, err)
	conf.GetConf().ServerConfig.ManualBackupReservedDays = &ManualBackupReservedDays
	conf.GetConf().ServerConfig.AutoBackupReservedDays = &AutoBackupReservedDays

	backupRequired1 := db.CreateBackupRequired{
		Name:         "xxx",
		Description:  "ttt",
		ClusterID:    db.ClusterID(cluster.ID),
		TidbCount:    3,
		TikvCount:    3,
		TiflashCount: 3,
		Type:         central.BackupType_AUTO,
	}
	backupRequired2 := db.CreateBackupRequired{
		Name:         "eee",
		Description:  "ttt",
		ClusterID:    db.ClusterID(cluster.ID),
		TidbCount:    3,
		TikvCount:    3,
		TiflashCount: 3,
		Type:         central.BackupType_MANUAL,
	}

	backup1, err := db.CreateBackup(logDB, user, *cluster, backupRequired1)
	assert.Nil(t, err)
	backup2, err := db.CreateBackup(logDB, user, *cluster, backupRequired2)
	assert.Nil(t, err)

	jobID1 := runtime.ProviderID{Namespace: runtimeutil.TiDBNamespace(backup1.ClusterID), ID: backupJobName(backup1)}
	jobID2 := runtime.ProviderID{Namespace: runtimeutil.TiDBNamespace(backup2.ClusterID), ID: backupJobName(backup2)}

	backupList, err := db.ListBackups(logDB, user, db.ClusterID(cluster.ID))
	assert.Nil(t, err)
	assert.Equal(t, 2, len(backupList))

	err = db.DeleteCluster(logDB, user, db.ClusterID(cluster.ID))
	assert.Nil(t, err)

	// Get client
	ctx, err := GetBgContext(t)
	assert.Nil(t, err)

	err = db.CreateBackupOperation(ctx, backup1, jobID1)
	assert.Nil(t, err)
	err = db.CreateBackupOperation(ctx, backup2, jobID2)
	assert.Nil(t, err)

	err = ctx.CleanupBackupRestoreJobs()
	assert.Nil(t, err)
	backupList, err = db.ListBackups(logDB, user, db.ClusterID(cluster.ID))
	assert.Nil(t, err)
	assert.Equal(t, 2, len(backupList))

	conf.GetConf().ServerConfig.AutoBackupReservedDays = &ZeroBackupReservedDays
	err = ctx.CleanupBackupRestoreJobs()
	assert.Nil(t, err)
	backupList, err = db.ListBackups(logDB, user, db.ClusterID(cluster.ID))
	assert.Nil(t, err)
	assert.Equal(t, 1, len(backupList))
	assert.Equal(t, "eee", backupList[0].Name)

	conf.GetConf().ServerConfig.ManualBackupReservedDays = &ZeroBackupReservedDays
	err = ctx.CleanupBackupRestoreJobs()
	assert.Nil(t, err)
	backupList, err = db.ListBackups(logDB, user, db.ClusterID(cluster.ID))
	assert.Nil(t, err)
	assert.Equal(t, 0, len(backupList))
}
*/