package test

import (
	"context"
	"testing"

	"queryorchestration/internal/serviceconfig/queue/clientsync"
	"queryorchestration/internal/serviceconfig/queue/documentclean"
	"queryorchestration/internal/serviceconfig/queue/documentinit"
	"queryorchestration/internal/serviceconfig/queue/documentsync"
	"queryorchestration/internal/serviceconfig/queue/documenttext"
	"queryorchestration/internal/serviceconfig/queue/query"
	"queryorchestration/internal/serviceconfig/queue/querysync"
	"queryorchestration/internal/serviceconfig/queue/queryversionsync"
	"queryorchestration/internal/serviceconfig/queue/storeevent"
)

type RunnerName string

const (
	StoreEventRunnerName       RunnerName = "storeEventRunner"
	DocInitRunnerName          RunnerName = "docInitRunner"
	DocSyncRunnerName          RunnerName = "docSyncRunner"
	DocCleanRunnerName         RunnerName = "docCleanRunner"
	DocTextRunnerName          RunnerName = "docTextRunner"
	QuerySyncRunnerName        RunnerName = "querySyncRunner"
	QueryRunnerName            RunnerName = "queryRunner"
	ClientSyncRunnerName       RunnerName = "clientSyncRunner"
	QueryVersionSyncRunnerName RunnerName = "queryVersionSyncRunner"
)

type RunnerEnv string

const (
	StoreEventRunnerEnv       RunnerEnv = storeevent.EnvName
	DocInitRunnerEnv          RunnerEnv = documentinit.EnvName
	DocSyncRunnerEnv          RunnerEnv = documentsync.EnvName
	DocCleanRunnerEnv         RunnerEnv = documentclean.EnvName
	DocTextRunnerEnv          RunnerEnv = documenttext.EnvName
	QuerySyncRunnerEnv        RunnerEnv = querysync.EnvName
	QueryRunnerEnv            RunnerEnv = query.EnvName
	ClientSyncRunnerEnv       RunnerEnv = clientsync.EnvName
	QueryVersionSyncRunnerEnv RunnerEnv = queryversionsync.EnvName
)

type Runner struct {
	Name             RunnerName
	DownstreamQueues []RunnerName
}

func GetRunnerEnvFromName(name RunnerName) RunnerEnv {
	switch name {
	case StoreEventRunnerName:
		return StoreEventRunnerEnv
	case DocInitRunnerName:
		return DocInitRunnerEnv
	case DocSyncRunnerName:
		return DocSyncRunnerEnv
	case DocCleanRunnerName:
		return DocCleanRunnerEnv
	case DocTextRunnerName:
		return DocTextRunnerEnv
	case QuerySyncRunnerName:
		return QuerySyncRunnerEnv
	case QueryRunnerName:
		return QueryRunnerEnv
	case ClientSyncRunnerName:
		return ClientSyncRunnerEnv
	case QueryVersionSyncRunnerName:
		return QueryVersionSyncRunnerEnv
	}
	return DocInitRunnerEnv
}

type RunnerConfig struct {
	Runner   Runner
	MockHTTP string
}

func CreateRunner(t testing.TB, ctx context.Context, cfg ContainerConfigProvider, network string, config *RunnerConfig) (*Container, func()) {
	env := map[string]string{}
	url := GetQueueURL(t, cfg, config.Runner.Name)
	env["QUEUE_URL"] = url

	c, cleanup := createContainer(t, ctx, network, &containerConfig{
		Name:             string(config.Runner.Name),
		DownstreamQueues: config.Runner.DownstreamQueues,
		Cfg:              cfg,
		Env:              env,
		MockHTTP:         config.MockHTTP,
		WaitForMsg:       "Listening to queue",
	})

	return &Container{
		Container: c,
		URI:       url,
	}, cleanup
}

var StoreEventRunner = Runner{
	Name:             StoreEventRunnerName,
	DownstreamQueues: []RunnerName{DocInitRunnerName},
}

var DocInitRunner = Runner{
	Name:             DocInitRunnerName,
	DownstreamQueues: []RunnerName{DocSyncRunnerName},
}

var DocSyncRunner = Runner{
	Name:             DocSyncRunnerName,
	DownstreamQueues: []RunnerName{DocCleanRunnerName},
}

var DocCleanRunner = Runner{
	Name:             DocCleanRunnerName,
	DownstreamQueues: []RunnerName{DocTextRunnerName},
}

var DocTextRunner = Runner{
	Name:             DocTextRunnerName,
	DownstreamQueues: []RunnerName{QuerySyncRunnerName},
}

var QuerySyncRunner = Runner{
	Name:             QuerySyncRunnerName,
	DownstreamQueues: []RunnerName{QueryRunnerName},
}

var QueryRunner = Runner{
	Name:             QueryRunnerName,
	DownstreamQueues: []RunnerName{QueryRunnerName},
}

var ClientSyncRunner = Runner{
	Name:             ClientSyncRunnerName,
	DownstreamQueues: []RunnerName{DocSyncRunnerName},
}

var QueryVersionSyncRunner = Runner{
	Name:             QueryVersionSyncRunnerName,
	DownstreamQueues: []RunnerName{ClientSyncRunnerName},
}

var runners = []Runner{
	StoreEventRunner,
	DocInitRunner,
	DocSyncRunner,
	DocCleanRunner,
	DocTextRunner,
	QuerySyncRunner,
	QueryRunner,
	ClientSyncRunner,
	QueryVersionSyncRunner,
}