package main

import (
	"context"
	"database/sql"
	"sync"
	"time"

	"github.com/pingcap/schrodinger-test/pkg/data"
	"github.com/pingcap/schrodinger/pkg/test_client"
)

func createBank(db *sql.DB) (*Bank2Case, error) {
	cfg := &Bank2CaseConfig{
		NumAccounts: 10000,
		Interval:    2 * time.Second,
		Contention:  "low",
		Concurrency: 200,
	}

	bank := NewBank2Case(cfg)
	err := bank.Initialize(context.Background(), db)
	if err != nil {
		client.Fatalf("initialize %s error %v", bank, err)
	}

	return bank, nil
}

func genData(bank *Bank2Case, db *sql.DB) {
	bank.moveMoney(db)
}

// GenData is gen data
type GenData struct {
	*data.GenCase
	isPause bool
	sync.RWMutex
}

func (g *GenData) pause() {
	g.Lock()
	g.isPause = true
	g.Unlock()
}

func (g *GenData) resume() {
	g.Lock()
	g.isPause = false
	g.Unlock()
}

func createGenData(db *sql.DB) *GenData {
	return &GenData{
		GenCase: data.NewGenCase(db),
		isPause: false,
	}
}

func (g *GenData) run(db *sql.DB) {
	for {
		g.RLock()
		if g.isPause {
			g.RUnlock()
			time.Sleep(1 * time.Second)
			continue
		}
		err := g.TypeTableSQL()
		if err != nil {
			client.Errorf("exec data failed %v", err)
		}

		err = g.BigTransaction()
		if err != nil {
			client.Errorf("exec transaction data failed %v", err)
		}
		g.RUnlock()

		time.Sleep(100 * time.Second)
	}
}