framework

const (
	EnvVarTestConfigs = "CTF_CONFIGS"
	//nolint
	EnvVarAWSSecretsManager = "CTF_AWS_SECRETS_MANAGER"
	// EnvVarCI this is a default env variable many CI runners use so code can detect we run in CI
	EnvVarCI = "CI"
)

const (
	DefaultConfigFilePath    = "env.toml"
	DefaultOverridesFilePath = "overrides.toml"
)

const (
	LocalGrafanaBaseURL    = "http://localhost:3000"
	LocalLokiBaseURL       = "http://localhost:3030"
	LocalPrometheusBaseURL = "http://localhost:9099"
	LocalPyroscopeBaseURL  = "http://localhost:4040"
	LocalCLNodeErrorsURL   = "http://localhost:3000/d/a7de535b-3e0f-4066-bed7-d505b6ec9ef1/cl-node-errors?orgId=1&refresh=5s"
	LocalWorkflowEngineURL = "http://localhost:3000/d/ce589a98-b4be-4f80-bed1-bc62f3e4414a/workflow-engine?orgId=1&refresh=5s&from=now-15m&to=now"
	LocalLogsURL           = "" /* 410-byte string literal not displayed */
	LocalPrometheusURL     = "" /* 350-byte string literal not displayed */
	LocalPostgresDebugURL  = "" /* 262-byte string literal not displayed */
	LocalPyroScopeURL      = "" /* 134-byte string literal not displayed */

	CTFCacheDir = ".local/share/ctf"
)

const (
	// ProductDashboardUUID is a default product dashboard uuid, can be static since it's our local environment
	ProductDashboardUUID = "f8a04cef-653f-46d3-86df-87c532300672"

	ReadmeTmpl = `## Chainlink Developer Environment

This template provides a complete Chainlink development environment with pre-configured infrastructure and observability tools, enabling rapid development while maintaining high quality standards.

🔧 Address all **TODO** comments and implement "product_configuration.go"

💻 Enter the shell:
` + "```" + `bash
just cli && {{ .CLIName }} sh
` + "```" + `

🚀 Spin up the environment
` + "```" + `bash
up ↵
` + "```" + `

🔍 Implement system-level smoke tests (tests/smoke_test.go) and run them:
` + "```" + `bash
test smoke ↵
` + "```" + `

📈 Implement load/chaos tests (tests/load_test.go) and run them:
` + "```" + `bash
test load ↵
` + "```" + `

🔄 **Enforce** quality standards in CI: copy .github/workflows to your CI folder, commit and make them pass
`
	// ProductsInterfaceTmpl common interface for arbitrary products deployed in devenv
	ProductsInterfaceTmpl = `` /* 885-byte string literal not displayed */

	// GoModTemplate go module template
	GoModTemplate = `` /* 726-byte string literal not displayed */

	// GitIgnoreTmpl default gitignore template
	GitIgnoreTmpl = `compose/
blockscout/
env-out.toml`

	// GrafanaDashboardTmpl is a Grafana dashboard template for your product
	GrafanaDashboardTmpl = `` /* 18430-byte string literal not displayed */

	// ConfigTOMLTmpl is a default env.toml template for devenv describind components configuration
	ConfigTOMLTmpl = `` /* 601-byte string literal not displayed */

	// CILoadChaosTemplate is a continuous integration template for end-to-end load/chaos tests
	CILoadChaosTemplate = `` /* 2408-byte string literal not displayed */

	// CISmokeTmpl is a continuous integration template for end-to-end smoke tests
	CISmokeTmpl = `` /* 2424-byte string literal not displayed */

	// CompletionTmpl is a go-prompt library completion template providing interactive prompt
	CompletionTmpl = `` /* 5175-byte string literal not displayed */

	// CLITmpl is a Cobra library CLI template with basic devenv commands
	CLITmpl = `` /* 8237-byte string literal not displayed */

	// LoadTestTmpl is a load/chaos test template
	LoadTestTmpl = `` /* 3234-byte string literal not displayed */

	SmokeTestImplTmpl = `` /* 914-byte string literal not displayed */

	// JDTmpl is a JobDistributor client wrappers
	JDTmpl = `` /* 1998-byte string literal not displayed */

	// DebugToolsTmpl is a template for various debug tools, tracing, tx debug, etc
	DebugToolsTmpl = `` /* 304-byte string literal not displayed */

	// ConfigTmpl is a template for reading and writing devenv configuration (env.toml, env-out.toml)
	ConfigTmpl = `` /* 3672-byte string literal not displayed */

	// EnvironmentTmpl is an environment.go template - main file for environment composition
	EnvironmentTmpl = `package {{ .PackageName }}

import (
	"context"
	"errors"
	"fmt"
	"os"
	"strings"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"

	"github.com/smartcontractkit/chainlink-testing-framework/framework"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/fake"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/jd"
	"github.com/smartcontractkit/{{ .ProductName }}/devenv/products/{{ .ProductName }}"

	ns "github.com/smartcontractkit/chainlink-testing-framework/framework/components/simple_node_set"
)

var L = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "{{ .ProductName }}"}).Logger()

type ProductInfo struct {
	Name      string ` + "`" + `toml:"name"` + "`" + `
	Instances int    ` + "`" + `toml:"instances"` + "`" + `
}

type Cfg struct {
	Products    []*ProductInfo      ` + "`" + `toml:"products"` + "`" + `
	Blockchains []*blockchain.Input ` + "`" + `toml:"blockchains" validate:"required"` + "`" + `
	FakeServer  *fake.Input         ` + "`" + `toml:"fake_server" validate:"required"` + "`" + `
	NodeSets    []*ns.Input         ` + "`" + `toml:"nodesets"    validate:"required"` + "`" + `
	JD          *jd.Input           ` + "`" + `toml:"jd"` + "`" + `
}

func newProduct(name string) (Product, error) {
	switch name {
	case "{{ .ProductName }}":
		return {{ .ProductName }}.NewConfigurator(), nil
	default:
		return nil, fmt.Errorf("unknown product type: %s", name)
	}
}

func NewEnvironment(ctx context.Context) error {
	if err := framework.DefaultNetwork(nil); err != nil {
		return err
	}
	in, err := Load[Cfg]()
	if err != nil {
		return fmt.Errorf("failed to load configuration: %w", err)
	}
	_, err = blockchain.NewBlockchainNetwork(in.Blockchains[0])
	if err != nil {
		return fmt.Errorf("failed to create blockchain network 1337: %w", err)
	}
	if os.Getenv("FAKE_SERVER_IMAGE") != "" {
		in.FakeServer.Image = os.Getenv("FAKE_SERVER_IMAGE")
	}
	_, err = fake.NewDockerFakeDataProvider(in.FakeServer)
	if err != nil {
		return fmt.Errorf("failed to create fake data provider: %w", err)
	}

	// get all the product orchestrations, generate product specific overrides
	productConfigurators := make([]Product, 0)
	nodeConfigs := make([]string, 0)
	nodeSecrets := make([]string, 0)
	for _, product := range in.Products {
		p, err := newProduct(product.Name)
		if err != nil {
			return err
		}
		if err = p.Load(); err != nil {
			return fmt.Errorf("failed to load product config: %w", err)
		}

		cfg, err := p.GenerateNodesConfig(ctx, in.FakeServer, in.Blockchains[0], in.NodeSets[0])
		if err != nil {
			return fmt.Errorf("failed to generate CL nodes config: %w", err)
		}
		nodeConfigs = append(nodeConfigs, cfg)

		secrets, err := p.GenerateNodesSecrets(ctx, in.FakeServer, in.Blockchains[0], in.NodeSets[0])
		if err != nil {
			return fmt.Errorf("failed to generate CL nodes config: %w", err)
		}
		nodeSecrets = append(nodeSecrets, secrets)

		productConfigurators = append(productConfigurators, p)
	}

	// merge overrides, spin up node sets and write infrastructure outputs
	// infra is always common for all the products, if it can't be we should fail
	// user should use different infra layout in env.toml then
	for _, ns := range in.NodeSets[0].NodeSpecs {
		ns.Node.TestConfigOverrides = strings.Join(nodeConfigs, "\n")
		ns.Node.TestSecretsOverrides = strings.Join(nodeSecrets, "\n")
		if os.Getenv("CHAINLINK_IMAGE") != "" {
			ns.Node.Image = os.Getenv("CHAINLINK_IMAGE")
		}
	}
	_, err = ns.NewSharedDBNodeSet(in.NodeSets[0], nil)
	if err != nil {
		return fmt.Errorf("failed to create new shared db node set: %w", err)
	}
	if err := Store[Cfg](in); err != nil {
		return err
	}

	// deploy all products and all instances,
	// product config function controls what to read and how to orchestrate each instance
	// via their own TOML part, we only deploy N instances of product M
	for productIdx, productInfo := range in.Products {
		for productInstance := range productInfo.Instances {
			err = productConfigurators[productIdx].ConfigureJobsAndContracts(
				ctx,
				in.FakeServer,
				in.Blockchains[0],
				in.NodeSets[0],
			)
			if err != nil {
				return fmt.Errorf("failed to setup default product deployment: %w", err)
			}
			if err := productConfigurators[productIdx].Store("env-out.toml", productInstance); err != nil {
				return errors.New("failed to store product config")
			}
		}
	}
	L.Info().Str("BootstrapNode", in.NodeSets[0].Out.CLNodes[0].Node.ExternalURL).Send()
	for _, n := range in.NodeSets[0].Out.CLNodes[1:] {
		L.Info().Str("Node", n.Node.ExternalURL).Send()
	}
	return nil
}
`
	// JustFileTmpl is a Justfile template used for building and publishing Docker images
	JustFileTmpl = `` /* 311-byte string literal not displayed */

)

const (
	ProductSoakConfigTmpl = `` /* 272-byte string literal not displayed */

	ProductBasicConfigTmpl = `` /* 211-byte string literal not displayed */

	ProductsImplTmpl = `package {{ .ProductName }}

import (
	"context"
	"fmt"
	"os"

	"github.com/rs/zerolog"
	"github.com/rs/zerolog/log"

	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/blockchain"
	"github.com/smartcontractkit/chainlink-testing-framework/framework/components/fake"
	nodeset "github.com/smartcontractkit/chainlink-testing-framework/framework/components/simple_node_set"
	"github.com/smartcontractkit/{{ .ProductName }}/devenv/products"
)

var L = log.Output(zerolog.ConsoleWriter{Out: os.Stderr}).Level(zerolog.DebugLevel).With().Fields(map[string]any{"component": "{{ .ProductName }}"}).Logger()

type ProductConfig struct {
	Out *ProductConfigOutput ` + "`" + `toml:"out"` + "`" + `
}

type ProductConfigOutput struct {
	ExampleField string ` + "`" + `toml:"example"` + "`" + `
}

type Configurator struct {
	Config []*ProductConfig ` + "`" + `toml:"{{ .ProductName }}"` + "`" + `
}

func NewConfigurator() *Configurator {
	return &Configurator{}
}

func (m *Configurator) Load() error {
	cfg, err := products.Load[Configurator]()
	if err != nil {
		return fmt.Errorf("failed to load product config: %w", err)
	}
	m.Config = cfg.Config
	return nil
}

func (m *Configurator) Store(path string, idx int) error {
	if err := products.Store(".", m); err != nil {
		return fmt.Errorf("failed to store product config: %w", err)
	}
	return nil
}

func (m *Configurator) GenerateNodesConfig(
	ctx context.Context,
	fs *fake.Input,
	bc *blockchain.Input,
	ns *nodeset.Input,
) (string, error) {
	L.Info().Msg("Generating Chainlink node config")
	// node
	_ = bc.Out.Nodes[0]
	// chain ID
	_ = bc.Out.ChainID
	return "", nil
}

func (m *Configurator) GenerateNodesSecrets(
	ctx context.Context,
	fs *fake.Input,
	bc *blockchain.Input,
	ns *nodeset.Input,
) (string, error) {
	L.Info().Msg("Generating Chainlink node secrets")
	// node
	_ = bc.Out.Nodes[0]
	// chain ID
	_ = bc.Out.ChainID
	return "", nil
}

func (m *Configurator) ConfigureJobsAndContracts(
	ctx context.Context,
	fake *fake.Input,
	bc *blockchain.Input,
	ns *nodeset.Input,
) error {
	// write an example output of your product configuration
	// contract addresses, URLs, etc
	// in soak test case it may hold multiple configs and have different outputs
	// for each instance
	m.Config[0].Out = &ProductConfigOutput{ExampleField: "my_data"}
	L.Info().Msg("Configuring product: {{ .ProductName }}")
	return nil
}
`

	ProductsConfigTmpl = `` /* 2435-byte string literal not displayed */

	ProductsCommonTmpl = `` /* 4951-byte string literal not displayed */

)

const (
	ProductFakesJustfile = `` /* 708-byte string literal not displayed */

	ProductFakesImplTmpl = `` /* 700-byte string literal not displayed */

	ProductFakesGoModuleTmpl = `` /* 363-byte string literal not displayed */

	ProductFakesDockerfileTmpl = `` /* 314-byte string literal not displayed */

)

const (
	DefaultCTFLogsDir = "logs/docker"
)

const (
	DefaultConfigDir = "."
)

const (
	EnvVarIgnoreCriticalLogs = "CTF_IGNORE_CRITICAL_LOGS"
)

const (
	EnvVarLogLevel = "CTF_LOG_LEVEL"
)