//nolint:unused // skip for unstable test, for readability.
package worker

import (
	"context"
	"time"

	"github.com/go-logr/logr"
	"github.com/pingcap/errors"
	"github.com/tidbcloud/aws-shared-provider/tests/framework"
)

var _ worker = &ttlWorker{}

const (
	ttlPollInterval = 1 * time.Minute
	ttlPollTimeout  = 30 * time.Minute
)

type ttlWorker struct {
	wctx   *workerContext
	logger logr.Logger
}

func newTTLWorker(f *framework.Framework, wctx *workerContext) *ttlWorker {
	logger := f.Logger.WithName("ttl")
	return &ttlWorker{
		wctx:   wctx,
		logger: logger,
	}
}

func (w *ttlWorker) name() string {
	return "ttl"
}

func (w *ttlWorker) triggerJob(ctx context.Context) error {
	sql := "create table test.ttl_t(a int, created_at TIMESTAMP) TTL = `created_at` + INTERVAL 1 minute;"
	_, err := w.wctx.db.ExecContext(ctx, sql)
	if err != nil {
		return err
	}

	_, err = w.wctx.db.ExecContext(ctx, `insert into test.ttl_t value(1, current_timestamp())`)
	if err != nil {
		return err
	}

	return nil
}

func (w *ttlWorker) verifyJob(ctx context.Context) error {
	ticker := time.NewTicker(ttlPollInterval)
	timer := time.NewTicker(ttlPollTimeout)
	now := time.Now()

	defer func() {
		ticker.Stop()
		timer.Stop()
		w.logger.Info("verifyJob done", "takes", time.Since(now))
	}()
	for {
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-ticker.C:
			sql := `select count(*) from test.ttl_t`
			rows, err := w.wctx.db.QueryContext(ctx, sql)
			if err != nil || !rows.Next() {
				continue
			}
			if rows.Err() != nil {
				return rows.Err()
			}
			var count int64
			err = rows.Scan(&count)
			if err != nil {
				return err
			}
			if count == 0 {
				return nil
			}
		case <-timer.C:
			return errors.Errorf("waiting for ttl job timeout")
		}
	}
}