package adapter_test

import (
	"fmt"
	"log"
	"net"
	"net/url"
	"os"
	"testing"
	"time"

	"github.com/ory/dockertest/v3"
	"github.com/ory/dockertest/v3/docker"
	"github.com/pressly/goose/v3"
)

const envDBDSN = "TESTS_DB_DSN"

func TestMain(m *testing.M) {
	goose.SetBaseFS(os.DirFS("../../migrations"))
	goose.SetLogger(goose.NopLogger())

	_, isDBDSNPresent := os.LookupEnv(envDBDSN)

	// all required envs are set, there is no need to use dockertest
	if isDBDSNPresent {
		os.Exit(m.Run())
	}

	pool, err := dockertest.NewPool("")
	if err != nil {
		log.Fatalf("couldn't construct pool: %s", err)
	}

	pool.MaxWait = 30 * time.Second
	if err = pool.Client.Ping(); err != nil {
		log.Fatalf("couldn't connect to Docker: %s", err)
	}

	var resources []*dockertest.Resource

	if !isDBDSNPresent {
		resource, dsn := newPostgres(pool)
		_ = os.Setenv(envDBDSN, dsn.String())
		resources = append(resources, resource)
	}

	code := m.Run()

	for _, r := range resources {
		_ = pool.Purge(r)
	}

	os.Exit(code)
}

func newPostgres(pool *dockertest.Pool) (*dockertest.Resource, *url.URL) {
	q := url.Values{}
	q.Add("sslmode", "disable")
	dsn := &url.URL{
		Scheme:   "postgres",
		User:     url.UserPassword("postgres", "postgres"),
		Path:     "twhelpdb",
		RawQuery: q.Encode(),
	}

	pw, _ := dsn.User.Password()

	resource, runErr := pool.RunWithOptions(&dockertest.RunOptions{
		Repository: "postgres",
		Tag:        "14.8",
		Env: []string{
			fmt.Sprintf("POSTGRES_USER=%s", dsn.User.Username()),
			fmt.Sprintf("POSTGRES_PASSWORD=%s", pw),
			fmt.Sprintf("POSTGRES_DB=%s", dsn.Path),
		},
	}, func(config *docker.HostConfig) {
		config.AutoRemove = true
		config.RestartPolicy = docker.RestartPolicy{
			Name: "no",
		}
	})
	if runErr != nil {
		log.Fatalf("couldn't run postgres: %s", runErr)
	}

	_ = resource.Expire(120)

	dsn.Host = getHostPort(resource, "5432/tcp")

	return resource, dsn
}

func getHostPort(resource *dockertest.Resource, id string) string {
	dockerURL := os.Getenv("DOCKER_HOST")
	if dockerURL == "" {
		return resource.GetHostPort(id)
	}

	u, err := url.Parse(dockerURL)
	if err != nil {
		log.Fatalf("couldn't parse DOCKER_HOST: %s", err)
	}

	return net.JoinHostPort(u.Hostname(), resource.GetPort(id))
}