package task

import (
	"context"
	"time"

	"sigs.k8s.io/controller-runtime/pkg/client"

	"github.com/go-logr/logr"
	"github.com/tidbcloud/eks-provider/api/v1alpha1"
	cloudv1 "github.com/tidbcloud/infra-api/api/v1"
	"github.com/tidbcloud/infra-provider/pkg/deploy"
	"github.com/tidbcloud/infra-provider/pkg/k8s"

	"github.com/tidbcloud/chaos-provider/pkg/config"
	chaosk8s "github.com/tidbcloud/chaos-provider/pkg/k8s"
)

const Finalizer = "chaos.cloud.pingcap.com/finalizer"

type Context struct {
	Local              client.Client
	Remote             k8s.ClientGetter
	Logger             logr.Logger
	ProviderType       string
	Network            *cloudv1.Network
	ChaosServer        *v1alpha1.ChaosServer
	BeginAt            *time.Time
	Config             config.ChaosConfig
	ChaosWorkflow      *v1alpha1.ChaosWorkflow
	ChaosWorkflowNodes *[]v1alpha1.ChaosWorkflowNode
}

func (c *Context) Default() (*Context, error) {
	return c, nil
}

func (c *Context) SetRemoteClient(ctx context.Context) error {
	scheme, err := chaosk8s.ChaosServerScheme()
	if err != nil {
		return err
	}

	g, err := k8s.NetworkClientGetter(ctx, c.Local, c.Network, scheme)
	if err != nil {
		return err
	}

	c.Remote = k8s.NewCacheClientGetter(g)
	return nil
}

var _ deploy.Task = &BaseTask{}

type BaseTask struct {
	*Context
}

func (t *BaseTask) Name() string {
	return ""
}

func (t *BaseTask) Category() deploy.TaskCategory {
	return deploy.ClusterTask
}

func (t *BaseTask) Create(ctx context.Context) deploy.Result {
	return deploy.Done()
}

func (t *BaseTask) PostCreate(ctx context.Context) deploy.Result {
	return deploy.Done()
}

func (t *BaseTask) Delete(ctx context.Context) deploy.Result {
	return deploy.Done()
}

func (t *BaseTask) PostDelete(ctx context.Context) deploy.Result {
	return deploy.Done()
}

func (t *BaseTask) MetricsStartTime() *time.Time {
	return t.BeginAt
}