package ci_ingo

import (
	"os"
	"testing"

	"github.com/stretchr/testify/assert"
)

var environment = map[string]string{
	"APPVEYOR":   "true",
	"APPVEYOR_X": "1",
	"CODEBUILD":  "",
}

func TestSimpleMatcher(t *testing.T) {
	params := []struct {
		name   string
		envvar string
		expect bool
	}{
		{"appveyor present", "APPVEYOR", true},
		{"codebuild present", "CODEBUILD", true},
		{"travis not present", "TRAVIS", false},
	}

	for _, p := range params {
		t.Run(p.name, func(t *testing.T) {
			matcher := simpleEnvMatcher{p.envvar}
			res := matcher.matchEnv(environment)
			assert.Equal(t, p.expect, res)
		})
	}
}

func TestAnyMatcher(t *testing.T) {
	params := []struct {
		name    string
		envvars []string
		expect  bool
	}{
		{"appveyor present", []string{"APPVEYOR_X", "APPVEYOR"}, true},
		{"codebuild present", []string{"CODEBUILD", "CODEBUILD_X"}, true},
		{"travis not present", []string{"TRAVIS_X", "TRAVIS"}, false},
	}

	for _, p := range params {
		t.Run(p.name, func(t *testing.T) {
			matcher := anyEnvMatcher{p.envvars}
			res := matcher.matchEnv(environment)
			assert.Equal(t, p.expect, res)
		})
	}
}

func TestAllMatcher(t *testing.T) {
	params := []struct {
		name    string
		envvars []string
		expect  bool
	}{
		{"appveyor present", []string{"APPVEYOR_X", "APPVEYOR"}, true},
		{"codebuild not present", []string{"CODEBUILD", "CODEBUILD_X"}, false},
		{"travis not present", []string{"TRAVIS_X", "TRAVIS"}, false},
	}

	for _, p := range params {
		t.Run(p.name, func(t *testing.T) {
			matcher := allEnvMatcher{p.envvars}
			res := matcher.matchEnv(environment)
			assert.Equal(t, p.expect, res)
		})
	}
}

func TestNeMatcher(t *testing.T) {
	params := []struct {
		name   string
		envvar string
		cmp    string
		expect bool
	}{
		{"appveyor present", "APPVEYOR", "false", true},
		{"codebuild not present", "CODEBUILD", "", false},
		{"travis not present", "TRAVIS", "true", false},
	}

	for _, p := range params {
		t.Run(p.name, func(t *testing.T) {
			matcher := neEnvMatcher{p.envvar, p.cmp}
			res := matcher.matchEnv(environment)
			assert.Equal(t, p.expect, res)
		})
	}
}

func TestGetCI(t *testing.T) {
	params := []struct {
		name       string
		envvars    map[string]string
		ciName     string
		ciConstant string
		isPR       bool
	}{
		{
			"AppVeyor - PR",
			map[string]string{"APPVEYOR": "true", "APPVEYOR_PULL_REQUEST_NUMBER": "42"},
			"AppVeyor", "APPVEYOR", true,
		},
		{
			"AppVeyor - No PR",
			map[string]string{"APPVEYOR": "true"},
			"AppVeyor", "APPVEYOR", false,
		},
		{
			"Azure Pipelines - PR",
			map[string]string{
				"SYSTEM_TEAMFOUNDATIONCOLLECTIONURI": "https://dev.azure.com/Contoso",
				"SYSTEM_PULLREQUEST_PULLREQUESTID":   "42",
			},
			"Azure Pipelines", "AZURE_PIPELINES", true,
		},
		{
			"Azure Pipelines - No PR",
			map[string]string{
				"SYSTEM_TEAMFOUNDATIONCOLLECTIONURI": "https://dev.azure.com/Contoso",
			},
			"Azure Pipelines", "AZURE_PIPELINES", false,
		},
		{
			"Bitbucket Pipelines - PR",
			map[string]string{
				"BITBUCKET_COMMIT": "true",
				"BITBUCKET_PR_ID":  "42",
			},
			"Bitbucket Pipelines", "BITBUCKET", true,
		},
		{
			"Bitbucket Pipelines - No PR",
			map[string]string{
				"BITBUCKET_COMMIT": "true",
			},
			"Bitbucket Pipelines", "BITBUCKET", false,
		},
		{
			"Buildkite - PR",
			map[string]string{
				"BUILDKITE":              "true",
				"BUILDKITE_PULL_REQUEST": "42",
			},
			"Buildkite", "BUILDKITE", true,
		},
		{
			"Buildkite - No PR",
			map[string]string{
				"BUILDKITE":              "true",
				"BUILDKITE_PULL_REQUEST": "false",
			},
			"Buildkite", "BUILDKITE", false,
		},
		{
			"CircleCI - PR",
			map[string]string{
				"CIRCLECI":            "true",
				"CIRCLE_PULL_REQUEST": "42",
			},
			"CircleCI", "CIRCLE", true,
		},
		{
			"CircleCI - No PR",
			map[string]string{
				"CIRCLECI": "true",
			},
			"CircleCI", "CIRCLE", false,
		},
		{
			"Cirrus CI - PR",
			map[string]string{
				"CIRRUS_CI": "true",
				"CIRRUS_PR": "42",
			},
			"Cirrus CI", "CIRRUS", true,
		},
		{
			"Cirrus CI - No PR",
			map[string]string{
				"CIRRUS_CI": "true",
			},
			"Cirrus CI", "CIRRUS", false,
		},
		{
			"Codefresh - PR",
			map[string]string{
				"CF_BUILD_ID":        "true",
				"CF_PULL_REQUEST_ID": "42",
			},
			"Codefresh", "CODEFRESH", true,
		},
		{
			"Codefresh - No PR",
			map[string]string{
				"CF_BUILD_ID": "true",
			},
			"Codefresh", "CODEFRESH", false,
		},
		{
			"LayerCI - PR",
			map[string]string{
				"LAYERCI":              "true",
				"LAYERCI_PULL_REQUEST": "https://link-to-pr/5",
			},
			"LayerCI", "LAYERCI", true,
		},
		{
			"LayerCI - No PR",
			map[string]string{
				"LAYERCI": "true",
			},
			"LayerCI", "LAYERCI", false,
		},
		{
			"Appcircle",
			map[string]string{"AC_APPCIRCLE": "true"},
			"Appcircle", "APPCIRCLE", false,
		},
		{
			"Render - PR",
			map[string]string{
				"RENDER":          "true",
				"IS_PULL_REQUEST": "true",
			},
			"Render", "RENDER", true,
		},
		{
			"Render - No PR",
			map[string]string{
				"RENDER":          "true",
				"IS_PULL_REQUEST": "false",
			},
			"Render", "RENDER", false,
		},
		{
			"Semaphore - PR",
			map[string]string{
				"SEMAPHORE":           "true",
				"PULL_REQUEST_NUMBER": "42",
			},
			"Semaphore", "SEMAPHORE", true,
		},
		{
			"Semaphore - No PR",
			map[string]string{
				"SEMAPHORE": "true",
			},
			"Semaphore", "SEMAPHORE", false,
		},
		{
			"Shippable - PR",
			map[string]string{
				"SHIPPABLE":       "true",
				"IS_PULL_REQUEST": "true",
			},
			"Shippable", "SHIPPABLE", true,
		},
		{
			"Shippable - No PR",
			map[string]string{
				"SHIPPABLE":       "true",
				"IS_PULL_REQUEST": "false",
			},
			"Shippable", "SHIPPABLE", false,
		},
		{
			"Solano CI - PR",
			map[string]string{
				"TDDIUM":       "true",
				"TDDIUM_PR_ID": "42",
			},
			"Solano CI", "SOLANO", true,
		},
		{
			"Solano CI - No PR",
			map[string]string{
				"TDDIUM": "true",
			},
			"Solano CI", "SOLANO", false,
		},
		{
			"Travis CI - PR",
			map[string]string{
				"TRAVIS":              "true",
				"TRAVIS_PULL_REQUEST": "42",
			},
			"Travis CI", "TRAVIS", true,
		},
		{
			"Travis CI - No PR",
			map[string]string{
				"TRAVIS":              "true",
				"TRAVIS_PULL_REQUEST": "false",
			},
			"Travis CI", "TRAVIS", false,
		},
		{
			"Netlify CI - PR",
			map[string]string{
				"NETLIFY":      "true",
				"PULL_REQUEST": "true",
			},
			"Netlify CI", "NETLIFY", true,
		},
		{
			"Netlify CI - No PR",
			map[string]string{
				"NETLIFY":      "true",
				"PULL_REQUEST": "false",
			},
			"Netlify CI", "NETLIFY", false,
		},
		{
			"Vercel",
			map[string]string{"NOW_BUILDER": "1"},
			"Vercel", "VERCEL", false,
		},
		{
			"Nevercode - PR",
			map[string]string{
				"NEVERCODE":              "true",
				"NEVERCODE_PULL_REQUEST": "true",
			},
			"Nevercode", "NEVERCODE", true,
		},
		{
			"Nevercode - No PR",
			map[string]string{
				"NEVERCODE":              "true",
				"NEVERCODE_PULL_REQUEST": "false",
			},
			"Nevercode", "NEVERCODE", false,
		},
		{
			"GitHub Actions - PR",
			map[string]string{
				"GITHUB_ACTIONS":    "true",
				"GITHUB_EVENT_NAME": "pull_request",
			},
			"GitHub Actions", "GITHUB_ACTIONS", true,
		},
		{
			"GitHub Actions - No PR",
			map[string]string{
				"GITHUB_ACTIONS":    "true",
				"GITHUB_EVENT_NAME": "push",
			},
			"GitHub Actions", "GITHUB_ACTIONS", false,
		},
		{
			"Screwdriver - PR",
			map[string]string{
				"SCREWDRIVER":     "true",
				"SD_PULL_REQUEST": "1",
			},
			"Screwdriver", "SCREWDRIVER", true,
		},
		{
			"Screwdriver - No PR",
			map[string]string{
				"SCREWDRIVER":     "true",
				"SD_PULL_REQUEST": "false",
			},
			"Screwdriver", "SCREWDRIVER", false,
		},
		{
			"Visual Studio App Center",
			map[string]string{"APPCENTER_BUILD_ID": "1"},
			"Visual Studio App Center", "APPCENTER", false,
		},
		{
			"Unknown CI",
			map[string]string{"CI": "true"},
			"Unknown CI", "CI", false,
		},
	}

	for _, p := range params {
		t.Run(p.name, func(t *testing.T) {
			os.Clearenv()

			for envvar, value := range p.envvars {
				_ = os.Setenv(envvar, value)
			}

			ci := GetCI()

			assert.True(t, IsCI())
			assert.Equal(t, p.ciName, ci.Name)
			assert.Equal(t, p.ciConstant, ci.Constant)
			assert.Equal(t, p.isPR, ci.IsPR)
		})
	}
}

func TestNoCI(t *testing.T) {
	os.Clearenv()

	ci := GetCI()

	assert.False(t, IsCI())
	assert.Nil(t, ci)
}