/*
 * Copyright (C) 2017 eschao <esc.chao@gmail.com>
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package config

import (
	"os"
	"strconv"
	"testing"

	"git.mousesoft.ru/ms/config/test"
	"github.com/stretchr/testify/assert"
)

const (
	LOGIN_USER        = "test-login-user"
	LOGIN_PASSWORD    = "test-login-passwd"
	SERVICE_HOST      = "test-service-host"
	SERVICE_PORT      = 8080
	SERVICE_LOG_PATH  = "/var/log/service"
	SERVICE_LOG_LEVEL = "debug"
	DB_HOST           = "test-db-host"
	DB_PORT           = 9090
	DB_USER           = "test-db-user"
	DB_PASSWORD       = "test-db-password"
	DB_LOG_PATH       = "/var/log/db"
	DB_LOG_LEVEL      = "error"
)

func TestLoginConfigEnv(t *testing.T) {
	var err error

	assert := assert.New(t)

	err = os.Setenv("USER", LOGIN_USER)
	assert.NoError(err)

	err = os.Setenv("PASSWORD", LOGIN_PASSWORD)
	assert.NoError(err)

	defer func() { _ = os.Unsetenv("USER") }()
	defer func() { _ = os.Unsetenv("PASSWORD") }()

	loginConfig := test.LoginConfig{}
	assert.NoError(ParseEnv(&loginConfig))

	assert.Equal(LOGIN_USER, loginConfig.User)
	assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
}

func TestLoginConfigEnvWithPrefix(t *testing.T) {
	var err error

	assert := assert.New(t)

	err = os.Setenv("DB_USER", LOGIN_USER)
	assert.NoError(err)

	err = os.Setenv("DB_PASSWORD", LOGIN_PASSWORD)
	assert.NoError(err)

	defer func() { _ = os.Unsetenv("DB_USER") }()
	defer func() { _ = os.Unsetenv("DB_PASSWORD") }()

	loginConfig := test.LoginConfig{}
	assert.NoError(ParseEnvWith(&loginConfig, "DB_", parseValueEnv))
	assert.Equal(LOGIN_USER, loginConfig.User)
	assert.Equal(LOGIN_PASSWORD, loginConfig.Password)
}

func TestServiceConfigEnv(t *testing.T) {
	servicePrefix := "CONFIG_TEST_SERVICE_"
	serviceLogPrefix := servicePrefix + "LOG_"
	dbPrefix := servicePrefix + "DB_"
	dbLogPrefix := dbPrefix + "LOG_"
	assert := assert.New(t)

	err := os.Setenv(servicePrefix+"HOST", SERVICE_HOST)
	assert.NoError(err)

	err = os.Setenv(servicePrefix+"PORT", strconv.Itoa(SERVICE_PORT))
	assert.NoError(err)

	err = os.Setenv(serviceLogPrefix+"PATH", SERVICE_LOG_PATH)
	assert.NoError(err)

	err = os.Setenv(serviceLogPrefix+"LEVEL", SERVICE_LOG_LEVEL)
	assert.NoError(err)

	err = os.Setenv(dbPrefix+"HOST", DB_HOST)
	assert.NoError(err)

	err = os.Setenv(dbPrefix+"PORT", strconv.Itoa(DB_PORT))
	assert.NoError(err)

	err = os.Setenv(dbPrefix+"USER", DB_USER)
	assert.NoError(err)

	err = os.Setenv(dbPrefix+"PASSWORD", DB_PASSWORD)
	assert.NoError(err)

	err = os.Setenv(dbLogPrefix+"PATH", DB_LOG_PATH)
	assert.NoError(err)

	err = os.Setenv(dbLogPrefix+"LEVEL", DB_LOG_LEVEL)
	assert.NoError(err)

	defer func() { _ = os.Unsetenv(servicePrefix + "HOST") }()
	defer func() { _ = os.Unsetenv(servicePrefix + "PORT") }()
	defer func() { _ = os.Unsetenv(serviceLogPrefix + "PATH") }()
	defer func() { _ = os.Unsetenv(serviceLogPrefix + "LEVEL") }()
	defer func() { _ = os.Unsetenv(dbPrefix + "HOST") }()
	defer func() { _ = os.Unsetenv(dbPrefix + "PORT") }()
	defer func() { _ = os.Unsetenv(dbPrefix + "USER") }()
	defer func() { _ = os.Unsetenv(dbPrefix + "PASSWORD") }()
	defer func() { _ = os.Unsetenv(dbLogPrefix + "PATH") }()
	defer func() { _ = os.Unsetenv(dbLogPrefix + "LEVEL") }()

	serviceConfig := test.ServiceConfig{}
	assert.NoError(ParseEnv(&serviceConfig))
	assert.Equal(SERVICE_HOST, serviceConfig.Host)
	assert.Equal(SERVICE_PORT, serviceConfig.Port)
	assert.Equal(SERVICE_LOG_PATH, serviceConfig.Log.Path)
	assert.Equal(SERVICE_LOG_LEVEL, serviceConfig.Log.Level)
	assert.Equal(DB_HOST, serviceConfig.DBConfig.Host)
	assert.Equal(DB_PORT, serviceConfig.DBConfig.Port)
	assert.Equal(DB_USER, serviceConfig.DBConfig.User)
	assert.Equal(DB_PASSWORD, serviceConfig.DBConfig.Password)
	assert.Equal(DB_LOG_PATH, serviceConfig.DBConfig.Log.Path)
	assert.Equal(DB_LOG_LEVEL, serviceConfig.DBConfig.Log.Level)
}

func TestEnvUsage(t *testing.T) {
	conf := test.ServiceConfig{}
	assert.NoError(t, UsageEnv(os.Stdout, &conf))
}

func TestServiceLoginConfigEnv(t *testing.T) {
	var err error

	serviceLoginPrefix := "CONFIG_TEST_SERVICE_LOGIN_"
	assert := assert.New(t)

	err = os.Setenv(serviceLoginPrefix+"USER", LOGIN_USER)
	assert.NoError(err)

	err = os.Setenv(serviceLoginPrefix+"PASSWORD", LOGIN_PASSWORD)
	assert.NoError(err)

	defer func() { _ = os.Unsetenv(serviceLoginPrefix + "USER") }()
	defer func() { _ = os.Unsetenv(serviceLoginPrefix + "PASSWORD") }()

	serviceConfig := test.ServiceConfig{Login: &test.LoginConfig{}}
	assert.NoError(ParseEnv(&serviceConfig))
	assert.Equal(LOGIN_USER, serviceConfig.Login.User)
	assert.Equal(LOGIN_PASSWORD, serviceConfig.Login.Password)
}

func TestTypesConfigEnv(t *testing.T) {
	var err error

	typesPrefix := "CONFIG_TEST_"
	assert := assert.New(t)

	err = os.Setenv(typesPrefix+"BOOL", "true")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"STR", "test-string")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT8", "100")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT16", "1000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT", "10000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT32", "100000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT64", "1000000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT8", "200")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT16", "2000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT", "20000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT32", "200000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT64", "2000000")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"FLOAT32", "1.234")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"FLOAT64", "2222.33333")
	assert.NoError(err)

	defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "STR") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT16") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT64") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT8") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT16") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT64") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT64") }()

	typesConfig := test.TypesConfig{}

	err = ParseEnv(&typesConfig)
	assert.NoError(err)

	assert.True(typesConfig.BoolValue)
	assert.Equal("test-string", typesConfig.StrValue)
	assert.Equal(int8(100), typesConfig.Int8Value)
	assert.Equal(int16(1000), typesConfig.Int16Value)
	assert.Equal(10000, typesConfig.IntValue)
	assert.Equal(int32(100000), typesConfig.Int32Value)
	assert.Equal(int64(1000000), typesConfig.Int64Value)
	assert.Equal(uint8(200), typesConfig.Uint8Value)
	assert.Equal(uint16(2000), typesConfig.Uint16Value)
	assert.Equal(uint(20000), typesConfig.UintValue)
	assert.Equal(uint32(200000), typesConfig.Uint32Value)
	assert.Equal(uint64(2000000), typesConfig.Uint64Value)
	assert.Equal(float32(1.234), typesConfig.Float32Value)
	assert.Equal(float64(2222.33333), typesConfig.Float64Value)
}

func TestTypesConfigWithErrorEnv(t *testing.T) {
	var err error

	typesConfig := test.TypesConfig{}
	typesPrefix := "CONFIG_TEST_"
	assert := assert.New(t)

	err = os.Setenv(typesPrefix+"BOOL", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "BOOL")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT8", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "INT8")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT16", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "INT16")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "INT")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT32", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "INT32")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"INT64", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "INT64")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT8", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "UINT8")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT16", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "UINT16")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "UINT")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT32", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "UINT32")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"UINT64", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "UINT64")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"FLOAT32", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "FLOAT32")
	assert.NoError(err)

	err = os.Setenv(typesPrefix+"FLOAT64", "xxx")
	assert.NoError(err)

	assert.Error(ParseEnv(&typesConfig))

	err = os.Unsetenv(typesPrefix + "FLOAT64")
	assert.NoError(err)

	defer func() { _ = os.Unsetenv(typesPrefix + "BOOL") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT8") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT16") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "INT64") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT8") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT16") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "UINT64") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT32") }()
	defer func() { _ = os.Unsetenv(typesPrefix + "FLOAT64") }()
}

func TestSlicesConfigEnv(t *testing.T) {
	var err error

	prefix := "CONFIG_TEST_SLICES_"
	assert := assert.New(t)

	err = os.Setenv(prefix+"PATHS", "/var:/usr:/home")
	assert.NoError(err)

	err = os.Setenv(prefix+"DEBUG", "/root;/log;/opt")
	assert.NoError(err)

	err = os.Setenv(prefix+"VALUES", "1,2,4,5")
	assert.NoError(err)

	defer func() { _ = os.Unsetenv(prefix + "PATHS") }()
	defer func() { _ = os.Unsetenv(prefix + "DEBUG") }()
	defer func() { _ = os.Unsetenv(prefix + "VALUES") }()

	conf := test.SlicesConfig{}
	assert.NoError(ParseEnv(&conf))
	assert.Equal(3, len(conf.Paths))
	assert.Equal("/var", conf.Paths[0])
	assert.Equal("/usr", conf.Paths[1])
	assert.Equal("/home", conf.Paths[2])
	assert.Equal(3, len(conf.Debugs))
	assert.Equal("/root", conf.Debugs[0])
	assert.Equal("/log", conf.Debugs[1])
	assert.Equal("/opt", conf.Debugs[2])
	assert.Equal(4, len(conf.Values))
	assert.Equal(1, conf.Values[0])
	assert.Equal(2, conf.Values[1])
	assert.Equal(4, conf.Values[2])
	assert.Equal(5, conf.Values[3])
}