package config

import (
	"os"
	"testing"

	"github.com/pelletier/go-toml/v2"
	"github.com/stretchr/testify/assert"
	"github.com/urfave/cli/v2"

	cmd "codeberg.org/codeberg/pages/cli"
)

func runApp(t *testing.T, fn func(*cli.Context) error, args []string) {
	app := cmd.CreatePagesApp()
	app.Action = fn

	// os.Args always contains the binary name
	args = append([]string{"testing"}, args...)

	err := app.Run(args)
	assert.NoError(t, err)
}

func TestReadConfigShouldReturnEmptyConfigWhenConfigArgEmpty(t *testing.T) {
	runApp(
		t,
		func(ctx *cli.Context) error {
			cfg, err := ReadConfig(ctx)
			assert.Equal(t, &Config{}, cfg)

			return err
		},
		[]string{},
	)
}

func TestReadConfigShouldReturnConfigFromFileWhenConfigArgPresent(t *testing.T) {
	runApp(
		t,
		func(ctx *cli.Context) error {
			content, err := os.ReadFile("assets/test_config.toml")
			if err != nil {
				return err
			}

			expectedConfig := &Config{}
			err = toml.Unmarshal(content, expectedConfig)
			if err != nil {
				return err
			}

			cfg, err := ReadConfig(ctx)
			assert.Equal(t, expectedConfig, cfg)

			return err
		},
		[]string{"--config-file", "assets/test_config.toml"},
	)
}

func TestMergeServerConfigShouldAddDefaultBlacklistedPathsToBlacklistedPaths(t *testing.T) {
	runApp(
		t,
		func(ctx *cli.Context) error {
			cfg := &ServerConfig{}
			mergeServerConfig(ctx, cfg)

			expected := ALWAYS_BLACKLISTED_PATHS
			assert.Equal(t, expected, cfg.BlacklistedPaths)

			return nil
		},
		[]string{},
	)
}

func TestMergeServerConfigShouldReplaceAllExistingValuesGivenAllArgsExist(t *testing.T) {
	runApp(
		t,
		func(ctx *cli.Context) error {
			cfg := &ServerConfig{
				Host:               "original",
				Port:               8080,
				HttpPort:           80,
				HttpServerEnabled:  false,
				MainDomain:         "original",
				RawDomain:          "original",
				AllowedCorsDomains: []string{"original"},
				BlacklistedPaths:   []string{"original"},
			}

			mergeServerConfig(ctx, cfg)

			expectedConfig := &ServerConfig{
				Host:               "changed",
				Port:               8443,
				HttpPort:           443,
				HttpServerEnabled:  true,
				MainDomain:         "changed",
				RawDomain:          "changed",
				AllowedCorsDomains: []string{"changed"},
				BlacklistedPaths:   append([]string{"changed"}, ALWAYS_BLACKLISTED_PATHS...),
			}

			assert.Equal(t, expectedConfig, cfg)

			return nil
		},
		[]string{
			"--pages-domain", "changed",
			"--raw-domain", "changed",
			"--allowed-cors-domains", "changed",
			"--blacklisted-paths", "changed",
			"--host", "changed",
			"--port", "8443",
			"--http-port", "443",
			"--enable-http-server",
		},
	)
}

func TestMergeServerConfigShouldReplaceOnlyOneValueExistingValueGivenOnlyOneArgExists(t *testing.T) {
	type testValuePair struct {
		args     []string
		callback func(*ServerConfig)
	}
	testValuePairs := []testValuePair{
		{args: []string{"--host", "changed"}, callback: func(sc *ServerConfig) { sc.Host = "changed" }},
		{args: []string{"--port", "8443"}, callback: func(sc *ServerConfig) { sc.Port = 8443 }},
		{args: []string{"--http-port", "443"}, callback: func(sc *ServerConfig) { sc.HttpPort = 443 }},
		{args: []string{"--enable-http-server"}, callback: func(sc *ServerConfig) { sc.HttpServerEnabled = true }},
		{args: []string{"--pages-domain", "changed"}, callback: func(sc *ServerConfig) { sc.MainDomain = "changed" }},
		{args: []string{"--raw-domain", "changed"}, callback: func(sc *ServerConfig) { sc.RawDomain = "changed" }},
		{args: []string{"--allowed-cors-domains", "changed"}, callback: func(sc *ServerConfig) { sc.AllowedCorsDomains = []string{"changed", "changed"} }}, // don't ask why, the cli lib always adds two strings when running all tests and one when running a single test
		{args: []string{"--blacklisted-paths", "changed"}, callback: func(sc *ServerConfig) { sc.BlacklistedPaths = []string{"changed", "changed"} }},      // same here
	}

	for _, pair := range testValuePairs {
		runApp(
			t,
			func(ctx *cli.Context) error {
				cfg := ServerConfig{
					Host:               "original",
					Port:               8080,
					HttpPort:           80,
					HttpServerEnabled:  false,
					MainDomain:         "original",
					RawDomain:          "original",
					AllowedCorsDomains: []string{"original"},
					BlacklistedPaths:   []string{"original"},
				}

				expectedConfig := cfg
				pair.callback(&expectedConfig)
				expectedConfig.BlacklistedPaths = append(expectedConfig.BlacklistedPaths, ALWAYS_BLACKLISTED_PATHS...)

				mergeServerConfig(ctx, &cfg)

				assert.Equal(t, expectedConfig, cfg)

				return nil
			},
			pair.args,
		)
	}
}