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

import (
	"context"
	"database/sql"
	"fmt"

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

var _ worker = &remoteQueryWorker{}

type queryResult struct {
	rows *sql.Rows
	err  error
}

type remoteQueryWorker struct {
	wctx   *workerContext
	logger logr.Logger
	resch  chan queryResult
}

func newRemoteQueryWorker(f *framework.Framework, wctx *workerContext) *remoteQueryWorker {
	logger := f.Logger.WithName("remoteQuery")
	return &remoteQueryWorker{
		wctx:   wctx,
		logger: logger,
		resch:  make(chan queryResult, 1),
	}
}

func (w *remoteQueryWorker) name() string {
	return "remote-query"
}

func (w *remoteQueryWorker) triggerJob(ctx context.Context) error {
	_, err := w.wctx.db.ExecContext(ctx, `create table test.remote_query_t(a int)`)
	if err != nil {
		return err
	}

	_, err = w.wctx.db.ExecContext(ctx, `insert into test.remote_query_t values (1),(2),(3),(4),(5)`)
	if err != nil {
		return err
	}

	go func() {
		//nolint:rowserrcheck // rows will be checked in verifyJob
		rows, err := w.wctx.db.QueryContext(ctx, `select /*+ use_worker() */ * from test.remote_query_t`)
		w.resch <- queryResult{rows, err}
	}()

	return nil
}

func (w *remoteQueryWorker) verifyJob(ctx context.Context) error {
	select {
	case <-ctx.Done():
		return ctx.Err()
	case res := <-w.resch:
		if res.err != nil {
			return res.err
		}
		defer res.rows.Close() //nolint:errcheck // no need
		var count int
		for res.rows.Next() {
			count++
		}
		if res.rows.Err() != nil {
			return res.rows.Err()
		}
		if count != 5 { //nolint:mnd // 5 is the expected count
			return fmt.Errorf("unexpected count %d", count)
		}
		return nil
	}
}