package cmd

import (
	"github.com/AlekSi/pointer"
	"github.com/spf13/cobra"
	"github.com/tidbcloud/dataflow-service/app/container"
	"github.com/tidbcloud/dataflow-service/app/models/domain"
	bootstarpSerer "github.com/tidbcloud/dataflow-service/internal/cmd/bootstrap/server"
	"github.com/tidbcloud/dataflow-service/pkg/log"
	"go.uber.org/zap"
)

func registerBackupSettingJobFunc(cmd *cobra.Command) {
	{
		var (
			tenantID     uint64
			projectID    uint64
			clusterID    uint64
			providerType string
		)
		suBcmd := &cobra.Command{
			Use:   "test-create-backup-setting",
			Short: "test-create-backup-setting",
			RunE: func(cmd *cobra.Command, args []string) error {
				if _, err := bootstarpSerer.NewServer(cmd.Context(), bootstarpSerer.ServerOption{
					EnableEventBusConsumer: false,
				}); err != nil {
					return err
				}
				ctx := log.WithTraceID(cmd.Context())
				app := container.Global()
				req := &domain.CreateBackupSettingReqV2{
					TenantID:      pointer.To(tenantID),
					ProjectID:     pointer.To(projectID),
					ClusterID:     pointer.To(clusterID),
					CloudProvider: pointer.To(domain.InfraProviderType(providerType)),
				}
				err := app.BackupSettingModel.CreateBackupSetting(ctx, req)
				if err != nil {
					log.GetLogger(ctx).Error("create backup setting", zap.Error(err))
					return err
				}
				return nil
			},
		}
		suBcmd.Flags().Uint64VarP(&tenantID, "tenantID", "", 0, "")
		suBcmd.Flags().Uint64VarP(&projectID, "projectID", "", 0, "")
		suBcmd.Flags().Uint64VarP(&clusterID, "clusterID", "", 0, "")
		suBcmd.Flags().StringVarP(&providerType, "providerType", "", "", "")
		cmd.AddCommand(suBcmd)
	}
	{
		var clusterID uint64
		suBcmd := &cobra.Command{
			Use:   "test-delete-backup-setting",
			Short: "test-delete-backup-setting",
			RunE: func(cmd *cobra.Command, args []string) error {
				if _, err := bootstarpSerer.NewServer(cmd.Context(), bootstarpSerer.ServerOption{
					EnableEventBusConsumer: false,
				}); err != nil {
					return err
				}
				ctx := log.WithTraceID(cmd.Context())
				app := container.Global()
				req := &domain.DeleteBackupSettingReqV2{
					ClusterID: pointer.To(clusterID),
				}
				err := app.BackupSettingModel.DeleteBackupSetting(ctx, req)
				if err != nil {
					log.GetLogger(ctx).Error("delete backup setting", zap.Error(err))
					return err
				}
				log.GetLogger(ctx).Info("delete backup setting success", zap.Any("ClusterID", clusterID))
				return nil
			},
		}
		suBcmd.Flags().Uint64VarP(&clusterID, "clusterID", "", 0, "")
		cmd.AddCommand(suBcmd)
	}
	{
		var (
			clusterID uint64
			enable    bool
			regions   []string
		)
		suBcmd := &cobra.Command{
			Use:   "test-modify-bucket-setting",
			Short: "test-modify-bucket-setting",
			RunE: func(cmd *cobra.Command, args []string) error {
				if _, err := bootstarpSerer.NewServer(cmd.Context(), bootstarpSerer.ServerOption{
					EnableEventBusConsumer: false,
				}); err != nil {
					return err
				}
				ctx := log.WithTraceID(cmd.Context())
				app := container.Global()
				req := &domain.RegionSettingModificationReqV2{
					ClusterID: pointer.To(clusterID),
					Enable:    enable,
					Regions:   regions,
				}
				resp, err := app.BackupSettingModel.ModifyRegionSetting(ctx, req)
				if err != nil {
					log.GetLogger(ctx).Error("modify bucket setting", zap.Error(err))
					return err
				}
				log.GetLogger(ctx).Info("modify bucket setting success", zap.Any("resp", resp))
				return nil
			},
		}
		suBcmd.Flags().Uint64VarP(&clusterID, "clusterID", "", 0, "")
		suBcmd.Flags().BoolVarP(&enable, "enable", "", false, "")
		suBcmd.Flags().StringSliceVarP(&regions, "regions", "", []string{}, "")
		cmd.AddCommand(suBcmd)
	}

	{
		var (
			clusterID uint64
			enable    bool
		)
		suBcmd := &cobra.Command{
			Use:   "switch-pitr",
			Short: "switch-pitr",
			RunE: func(cmd *cobra.Command, args []string) error {
				if _, err := bootstarpSerer.NewServer(cmd.Context(), bootstarpSerer.ServerOption{
					EnableEventBusConsumer: false,
				}); err != nil {
					return err
				}
				ctx := log.WithTraceID(cmd.Context())
				app := container.Global()
				req := &domain.PitSettingModificationReq{
					ClusterID: clusterID,
					Enable:    enable,
				}
				err := app.BackupSettingModel.ModifyPitBackupSetting(ctx, req)
				if err != nil {
					log.GetLogger(ctx).Error("modify pitr setting", zap.Error(err))
					return err
				}
				log.GetLogger(ctx).Info("modify pitr setting success")
				return nil
			},
		}
		suBcmd.Flags().Uint64VarP(&clusterID, "cluster_id", "", 0, "")
		suBcmd.Flags().BoolVarP(&enable, "enable", "", false, "")
		cmd.AddCommand(suBcmd)
	}
}

func init() {
	backupSettingCmd := &cobra.Command{Use: "backup_setting", Short: "backup setting cmd"}
	backupSettingCmd.PreRunE = func(cmd *cobra.Command, args []string) error {
		return nil
	}

	registerBackupSettingJobFunc(backupSettingCmd)
	jobCmd.AddCommand(backupSettingCmd)
}