package initialize_test

import (
	"testing"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"github.com/stretchr/testify/assert"
	"golang.org/x/oauth2"
	"golang.org/x/oauth2/google"
	"golang.org/x/oauth2/vk"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/initialize"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/internal/models"
	"penahub.gitlab.yandexcloud.net/pena-services/customer/pkg/mongo"
)

func setDefaultTestingENV(t *testing.T) *models.Config {
	t.Helper()

	defaultGoogleURL := models.GoogleURL{
		Redirect:  "http://www.google.com/callback",
		OAuthHost: "http://www.google.com/oauth",
	}

	defaultVKURL := models.VKURL{
		Redirect: "http://www.vk.ru/callback",
	}

	defaultAmocrmURL := models.AmocrmURL{
		Redirect:    "http://www.amocrm.ru/callback",
		OAuthHost:   "http://www.amocrm.ru/oauth",
		UserInfo:    "http://www.amocrm.ru/user",
		AccessToken: "http://www.amocrm.ru/token",
	}

	defaultAuthURL := models.AuthMicroServiceURL{
		Exchange: "http://www.auth.ru/callback",
		Register: "http://www.auth.ru/register",
		User:     "http://www.auth.ru/user",
	}

	defaultGoogleOAuthConfiguration := oauth2.Config{
		RedirectURL:  defaultGoogleURL.Redirect,
		ClientID:     "google_client_id",
		ClientSecret: "google_client_secret",
		Scopes: []string{
			"openid",
			"https://www.googleapis.com/auth/userinfo.email",
			"https://www.googleapis.com/auth/userinfo.profile",
		},
		Endpoint: google.Endpoint,
	}

	defaultVKOAuthConfiguration := oauth2.Config{
		RedirectURL:  defaultVKURL.Redirect,
		ClientID:     "vk_client_id",
		ClientSecret: "vk_client_secret",
		Scopes:       []string{"email"},
		Endpoint:     vk.Endpoint,
	}

	defaultAmocrmOAuthConfiguration := oauth2.Config{
		RedirectURL:  defaultAmocrmURL.Redirect,
		ClientID:     "amocrm_client_id",
		ClientSecret: "amocrm_client_secret",
		Scopes:       nil,
		Endpoint: oauth2.Endpoint{
			AuthURL:   defaultAmocrmURL.OAuthHost,
			TokenURL:  defaultAmocrmURL.AccessToken,
			AuthStyle: models.BodyAuthStyle,
		},
	}

	defaultConfiguration := models.Config{
		HTTP: models.HTTPConfiguration{
			Host: "localhost",
			Port: "8080",
		},
		Service: models.ServiceConfiguration{
			Google: models.GoogleConfiguration{
				ClientID:     defaultGoogleOAuthConfiguration.ClientID,
				ClientSecret: defaultGoogleOAuthConfiguration.ClientSecret,
				OAuthConfig:  defaultGoogleOAuthConfiguration,
				URL:          defaultGoogleURL,
			},
			VK: models.VKConfiguration{
				ClientID:     defaultVKOAuthConfiguration.ClientID,
				ClientSecret: defaultVKOAuthConfiguration.ClientSecret,
				OAuthConfig:  defaultVKOAuthConfiguration,
				URL:          defaultVKURL,
			},
			Amocrm: models.AmocrmConfiguration{
				ClientID:     defaultAmocrmOAuthConfiguration.ClientID,
				ClientSecret: defaultAmocrmOAuthConfiguration.ClientSecret,
				OAuthConfig:  defaultAmocrmOAuthConfiguration,
				URL:          defaultAmocrmURL,
			},
			AuthMicroservice: models.AuthMicroserviceConfiguration{
				AuthGroup:      "group",
				PrivateSignKey: "key",
				URL:            defaultAuthURL,
			},
			JWT: models.JWTConfiguration{
				PrivateKey: "jwt private key",
				PublicKey:  "jwt public key",
				Issuer:     "issuer",
				Audience:   "audience",
				Algorithm:  *jwt.SigningMethodRS256,
				ExpiresIn:  15 * time.Minute,
			},
		},
		Database: mongo.Configuration{
			Host:         "localhost",
			Port:         "27017",
			User:         "user",
			Password:     "pass",
			Auth:         "db",
			DatabaseName: "db",
		},
	}

	t.Setenv("JWT_PUBLIC_KEY", defaultConfiguration.Service.JWT.PublicKey)
	t.Setenv("JWT_PRIVATE_KEY", defaultConfiguration.Service.JWT.PrivateKey)
	t.Setenv("JWT_ISSUER", defaultConfiguration.Service.JWT.Issuer)
	t.Setenv("JWT_AUDIENCE", defaultConfiguration.Service.JWT.Audience)

	t.Setenv("GOOGLE_CLIENT_ID", defaultConfiguration.Service.Google.ClientID)
	t.Setenv("GOOGLE_CLIENT_SECRET", defaultConfiguration.Service.Google.ClientSecret)
	t.Setenv("GOOGLE_REDIRECT_URL", defaultConfiguration.Service.Google.URL.Redirect)
	t.Setenv("GOOGLE_OAUTH_HOST", defaultConfiguration.Service.Google.URL.OAuthHost)

	t.Setenv("VK_CLIENT_ID", defaultConfiguration.Service.VK.ClientID)
	t.Setenv("VK_CLIENT_SECRET", defaultConfiguration.Service.VK.ClientSecret)
	t.Setenv("VK_REDIRECT_URL", defaultConfiguration.Service.VK.URL.Redirect)

	t.Setenv("AMOCRM_CLIENT_ID", defaultConfiguration.Service.Amocrm.ClientID)
	t.Setenv("AMOCRM_CLIENT_SECRET", defaultConfiguration.Service.Amocrm.ClientSecret)
	t.Setenv("AMOCRM_REDIRECT_URL", defaultConfiguration.Service.Amocrm.URL.Redirect)
	t.Setenv("AMOCRM_OAUTH_HOST", defaultConfiguration.Service.Amocrm.URL.OAuthHost)
	t.Setenv("AMOCRM_USER_INFO_URL", defaultConfiguration.Service.Amocrm.URL.UserInfo)
	t.Setenv("AMOCRM_ACCESS_TOKEN_URL", defaultConfiguration.Service.Amocrm.URL.AccessToken)

	t.Setenv("AUTH_MICROSERVICE_GROUP", defaultConfiguration.Service.AuthMicroservice.AuthGroup)
	t.Setenv("AUTH_MICROSERVICE_PRIVATE_SIGN_KEY", defaultConfiguration.Service.AuthMicroservice.PrivateSignKey)
	t.Setenv("AUTH_MICROSERVICE_EXHANGE_URL", defaultConfiguration.Service.AuthMicroservice.URL.Exchange)
	t.Setenv("AUTH_MICROSERVICE_REGISTER_URL", defaultConfiguration.Service.AuthMicroservice.URL.Register)
	t.Setenv("AUTH_MICROSERVICE_USER_URL", defaultConfiguration.Service.AuthMicroservice.URL.User)

	t.Setenv("MONGO_HOST", defaultConfiguration.Database.Host)
	t.Setenv("MONGO_PORT", defaultConfiguration.Database.Port)
	t.Setenv("MONGO_USER", defaultConfiguration.Database.User)
	t.Setenv("MONGO_PASSWORD", defaultConfiguration.Database.Password)
	t.Setenv("MONGO_AUTH", defaultConfiguration.Database.Auth)
	t.Setenv("MONGO_DB_NAME", defaultConfiguration.Database.DatabaseName)

	return &defaultConfiguration
}

func TestConfiguration(t *testing.T) {
	t.Run("Успешная инициализация конфигурации", func(t *testing.T) {
		defaultConfiguration := setDefaultTestingENV(t)

		assert.NotPanics(t, func() {
			configuration, err := initialize.Configuration("")

			assert.NoError(t, err)
			assert.Equal(t, defaultConfiguration, configuration)
		})
	})

	t.Run("Ошибка при наличии кривого url", func(t *testing.T) {
		setDefaultTestingENV(t)
		t.Setenv("AMOCRM_USER_INFO_URL", "url")

		assert.NotPanics(t, func() {
			configuration, err := initialize.Configuration("")

			assert.Error(t, err)
			assert.Nil(t, configuration)
		})
	})

	t.Run("Ошибка при отсутствии обязательного env", func(t *testing.T) {
		assert.NotPanics(t, func() {
			configuration, err := initialize.Configuration("")

			assert.Error(t, err)
			assert.Nil(t, configuration)
		})
	})
}