package localmetrics

import (
	"context"

	"github.com/Flaque/filet"

	// embeds the pyroscope config file.
	_ "embed"
	"fmt"
	"os"
	"time"

	"github.com/ory/dockertest/v3"
	"github.com/ory/dockertest/v3/docker"
	"github.com/ory/dockertest/v3/docker/types/mount"
	"github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/core"
	"github.com/synapsecns/sanguine/core/dockerutil"
	"github.com/synapsecns/sanguine/core/metrics/internal"
	"github.com/synapsecns/sanguine/core/processlog"
	"github.com/synapsecns/sanguine/core/retry"
)

//go:embed pyroscope.yaml
var pyroscopeConfig string

// pyroscopePath is the local path to the pyroscope config file.
const pyroscopePath = "/pyroscope.yaml"

// StartPyroscopeServer starts a new pyroscope instance.
// See:  https://github.com/grafana/pyroscope/blob/main/examples/tracing/jaeger/docker-compose.yml
// for details.
// nolint: cyclop
func (j *testJaeger) StartPyroscopeServer(ctx context.Context) *uiResource {
	if !j.cfg.enablePyroscope {
		return &uiResource{
			uiURL: core.GetEnv(internal.PyroscopeEndpoint, fmt.Sprintf("%s not found", internal.PyroscopeEndpoint)),
		}
	}
	if core.HasEnv(internal.PyroscopeEndpoint) {
		return &uiResource{
			uiURL: os.Getenv(internal.PyroscopeEndpoint),
		}
	}

	runOptions := &dockertest.RunOptions{
		Hostname:   "pyroscope",
		Repository: "pyroscope/pyroscope",
		Env: []string{
			fmt.Sprintf("PYROSCOPE_CONFIG=%s", pyroscopePath),
		},
		Tag:          "latest",
		Cmd:          []string{"server"},
		ExposedPorts: []string{"4040"},
		Networks:     j.getNetworks(),
		Labels: map[string]string{
			appLabel:   "pyroscope",
			runIDLabel: j.runID,
		},
	}

	// github actions functions on a bridge so the host mount happens on the machine host
	// rather than in the isolated container environment. This causes the pyroscope config
	// to be inaccessible. To get around this we remove the environment variables from the
	// container.
	// See:  https://stackoverflow.com/a/60202672 for details.
	if core.HasEnv("CI") {
		runOptions.Env = []string{}
	}

	resource, err := j.pool.RunWithOptions(runOptions, func(config *docker.HostConfig) {
		config.Mounts = []docker.HostMount{
			{
				Type:     string(mount.TypeBind),
				Target:   pyroscopePath,
				Source:   filet.TmpFile(j.tb, "", pyroscopeConfig).Name(),
				ReadOnly: true,
			},
		}
		config.VolumesFrom = []string{}
		config.AutoRemove = true
		config.RestartPolicy = docker.RestartPolicy{Name: "no"}
	})
	assert.Nil(j.tb, err)

	j.tb.Setenv(internal.PyroscopeEndpoint, fmt.Sprintf("http://localhost:%s", dockerutil.GetPort(resource, "4040/tcp")))

	if !j.cfg.keepContainers {
		err = resource.Expire(uint(keepAliveOnFailure.Seconds()))
		assert.Nil(j.tb, err)
	}

	// make sure client is alive
	err = retry.WithBackoff(ctx, checkURL(os.Getenv(internal.PyroscopeEndpoint)), retry.WithMax(time.Millisecond*10), retry.WithMax(time.Minute), retry.WithMaxAttempts(100))
	if err != nil {
		return nil
	}

	logResourceChan := make(chan *uiResource, 1)
	go func() {
		_ = dockerutil.TailContainerLogs(dockerutil.WithContext(ctx), dockerutil.WithPool(j.pool), dockerutil.WithProcessLogOptions(processlog.WithLogDir(j.logDir), processlog.WithLogFileName("pyroscope")), dockerutil.WithFollow(true),
			dockerutil.WithResource(resource), dockerutil.WithCallback(func(ctx context.Context, metadata processlog.LogMetadata) {
				select {
				case <-ctx.Done():
					return
				case logResourceChan <- &uiResource{
					Resource: resource,
					uiURL:    os.Getenv(internal.PyroscopeEndpoint),
				}:
					return
				}
			}))
	}()
	// make sure client is alive
	err = retry.WithBackoff(ctx, checkURL(os.Getenv(internal.PyroscopeEndpoint)), retry.WithMax(time.Millisecond*10), retry.WithMax(time.Minute))
	if err != nil {
		return nil
	}

	select {
	case <-ctx.Done():
		return nil
	case logResource := <-logResourceChan:
		return logResource
	}
}