package provider

import (
	"fmt"
	"os"
	"testing"

	"github.com/go-semantic-release/semantic-release/v2/pkg/provider"
	"github.com/go-semantic-release/semantic-release/v2/pkg/semrel"
	"github.com/stretchr/testify/require"
)

func TestNewZexlabRepository(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)

	var repo *ZexlabRepository
	repo = &ZexlabRepository{}
	err := repo.Init(map[string]string{})
	assertions.EqualError(err, "zexlab token missing")

	repo = &ZexlabRepository{}

	err = repo.Init(map[string]string{
		"server_url": server.URL,
		"slug":       fmt.Sprintf("%s/%s", zexlabUser, zexlabRepo),
		"token":      "token",
	})
	assertions.NoError(err)
}

func TestVersionAndNameReturn(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := createTestZexlabRepo(t)
	assertions.Equal("dev", repo.Version())
	assertions.Equal("Zexlab", repo.Name())
}

func TestZexlabGetInfo(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := createTestZexlabRepo(t)

	repoInfo, err := repo.GetInfo()

	assertions.NoError(err)
	assertions.Equal(zexlabDefaultBranch, repoInfo.DefaultBranch)
	assertions.True(repoInfo.Private)
	assertions.Equal(zexlabUser, repoInfo.Owner)
	assertions.Equal(zexlabRepo, repoInfo.Repo)
}

func TestZexlabGetCommits(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := createTestZexlabRepo(t)

	commits, err := repo.GetCommits("", "sa213445t6")

	assertions.NoError(err)
	for i, c := range commits {
		assertions.Equal(c.SHA, zexlabCommits[i].SHA)
		assertions.Equal(c.RawMessage, zexlabCommits[i].RepoCommit.Message)
		assertions.Equal(c.Annotations["author_name"], zexlabCommits[i].Author.FullName)
		assertions.Equal(c.Annotations["author_email"], zexlabCommits[i].Author.Email)
		assertions.Equal(c.Annotations["committer_name"], zexlabCommits[i].Committer.FullName)
		assertions.Equal(c.Annotations["committer_email"], zexlabCommits[i].Committer.Email)
		assertions.Equal(c.Annotations["author_date"], zexlabCommits[i].RepoCommit.Author.Date)
		assertions.Equal(c.Annotations["committer_date"], zexlabCommits[i].RepoCommit.Committer.Date)
	}
}

func TestZexlabGetReleases(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := createTestZexlabRepo(t)

	testCases := []struct {
		vRange          string
		re              string
		expectedSHA     string
		expectedVersion string
	}{
		{"", "", testSHA, "2020.4.19"},
		{"", "^v[0-9]*", testSHA, "2.0.0"},
		{"2-beta", "", testSHA, "2.1.0-beta"},
		{"3-beta", "", testSHA, "3.0.0-beta.2"},
		{"4-beta", "", testSHA, "4.0.0-beta"},
	}

	for _, tc := range testCases {
		t.Run(fmt.Sprintf("VersionRange: %s, Regex: %s", tc.vRange, tc.re), func(t *testing.T) {
			releases, err := repo.GetReleases(tc.re)
			assertions.NoError(err)
			release, err := semrel.GetLatestReleaseFromReleases(releases, tc.vRange)
			require.NoError(t, err)
			assertions.Equal(tc.expectedSHA, release.SHA)
			assertions.Equal(tc.expectedVersion, release.Version)
		})
	}
}

func TestZexlabCreateRelease(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := createTestZexlabRepo(t)

	err := repo.CreateRelease(&provider.CreateReleaseConfig{
		NewVersion: "5.0.0",
		Prerelease: false,
		Branch:     "",
		SHA:        testSHA,
	})
	assertions.NoError(err)
}

func TestZexlabCreateReleaseStripPrefix(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := &ZexlabRepository{}

	err := repo.Init(map[string]string{
		"server_url":         server.URL,
		"slug":               fmt.Sprintf("%s/%s", zexlabUser, zexlabRepo),
		"token":              "token",
		"strip_v_tag_prefix": "true",
	})

	assertions.NoError(err)

	err = repo.CreateRelease(&provider.CreateReleaseConfig{
		NewVersion: "5.0.0",
		Prerelease: false,
		Branch:     "",
		SHA:        testSHA,
	})
	assertions.NoError(err)
}

func TestZexlabInvalidTag(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)
	repo := &ZexlabRepository{}

	err := repo.Init(map[string]string{
		"server_url": server.URL,
		"slug":       fmt.Sprintf("%s/%s", zexlabUser, zexlabRepo),
		"token":      "token",
	})

	assertions.NoError(err)

	err = repo.CreateRelease(&provider.CreateReleaseConfig{
		NewVersion: "1.0.1",
		Prerelease: false,
		Branch:     "",
		SHA:        testSHA,
	})
	assertions.Errorf(err, "invalid tag name")
}

func TestZexlabEnvironmentVars(t *testing.T) {
	setup()
	defer teardown()

	testCases := []struct {
		name        string
		envVarName  string
		envVarValue string
	}{
		{
			"Gitea Environment Var Slug",
			"GITEA_REPOSITORY",
			fmt.Sprintf("%s/%s",
				zexlabUser,
				zexlabRepo),
		},
		{
			"GitHub Actions Environment Var Slug",
			"GITHUB_REPOSITORY",
			fmt.Sprintf("%s/%s",
				zexlabUser,
				zexlabRepo),
		},
		{
			"WoodpeckerCI Environment Var Slug",
			"CI_REPO_NAME",
			fmt.Sprintf("%s/%s",
				zexlabUser,
				zexlabRepo),
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			_ = os.Setenv(tc.envVarName, tc.envVarValue)

			repo := &ZexlabRepository{}
			err := repo.Init(map[string]string{
				"server_url": server.URL,
				"token":      "token",
			})

			require.NoError(t, err)
			_ = os.Unsetenv(tc.envVarName)
		})
	}
}

func TestZexlabTokenNotSet(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)

	repo := &ZexlabRepository{}
	err := repo.Init(map[string]string{
		"server_url": server.URL,
	})

	assertions.Errorf(err, "zexlab token missing")
}

func TestZexlabNonBooleanStripPrefix(t *testing.T) {
	setup()
	defer teardown()

	assertions := require.New(t)

	repo := &ZexlabRepository{}
	err := repo.Init(map[string]string{
		"server_url":         server.URL,
		"slug":               fmt.Sprintf("%s/%s", zexlabUser, zexlabRepo),
		"strip_v_tag_prefix": "something",
		"token":              "token",
	})

	assertions.Errorf(err, "failed to set property strip_v_tag_prefix: strconv.ParseBool: parsing \"something\": invalid syntax")
}