// Copyright © 2014 Steve Francia <spf@spf13.com>.

//

// Use of this source code is governed by an MIT-style

// license that can be found in the LICENSE file.

// Viper is an application configuration system.

// It believes that applications can be configured a variety of ways

// via flags, ENVIRONMENT variables, configuration files retrieved

// from the file system, or a remote key/value store.

// Each item takes precedence over the item below it:

// overrides

// flag

// env

// config

// key/value store

// default

package viper

import (

	"bytes"

	"encoding/csv"

	"encoding/json"

	"errors"

	"fmt"

	"io"

	"log"

	"os"

	"path/filepath"

	"reflect"

	"strings"

	"sync"

	"time"

	"github.com/fsnotify/fsnotify"

	"github.com/hashicorp/hcl"

	"github.com/hashicorp/hcl/hcl/printer"

	"github.com/magiconair/properties"

	"github.com/mitchellh/mapstructure"

	"github.com/pelletier/go-toml"

	"github.com/spf13/afero"

	"github.com/spf13/cast"

	jww "github.com/spf13/jwalterweatherman"

	"github.com/spf13/pflag"

	"github.com/subosito/gotenv"

	"gopkg.in/ini.v1"

	"gopkg.in/yaml.v2"

)

// ConfigMarshalError happens when failing to marshal the configuration.

type ConfigMarshalError struct {

	err error

}

// Error returns the formatted configuration error.

func (e ConfigMarshalError) Error() string {

	return fmt.Sprintf("While marshaling config: %s", e.err.Error())

}

var v *Viper

type RemoteResponse struct {

	Value []byte

	Error error

}

func init() {

	v = New()

}

type remoteConfigFactory interface {

	Get(rp RemoteProvider) (io.Reader, error)

	Watch(rp RemoteProvider) (io.Reader, error)

	WatchChannel(rp RemoteProvider) (<-chan *RemoteResponse, chan bool)

}

// RemoteConfig is optional, see the remote package

var RemoteConfig remoteConfigFactory

// UnsupportedConfigError denotes encountering an unsupported

// configuration filetype.

type UnsupportedConfigError string

// Error returns the formatted configuration error.

func (str UnsupportedConfigError) Error() string {

	return fmt.Sprintf("Unsupported Config Type %q", string(str))

}

// UnsupportedRemoteProviderError denotes encountering an unsupported remote

// provider. Currently only etcd and Consul are supported.

type UnsupportedRemoteProviderError string

// Error returns the formatted remote provider error.

func (str UnsupportedRemoteProviderError) Error() string {

	return fmt.Sprintf("Unsupported Remote Provider Type %q", string(str))

}

// RemoteConfigError denotes encountering an error while trying to

// pull the configuration from the remote provider.

type RemoteConfigError string

// Error returns the formatted remote provider error

func (rce RemoteConfigError) Error() string {

	return fmt.Sprintf("Remote Configurations Error: %s", string(rce))

}

// ConfigFileNotFoundError denotes failing to find configuration file.

type ConfigFileNotFoundError struct {

	name, locations string

}

// Error returns the formatted configuration error.

func (fnfe ConfigFileNotFoundError) Error() string {

	return fmt.Sprintf("Config File %q Not Found in %q", fnfe.name, fnfe.locations)

}

// ConfigFileAlreadyExistsError denotes failure to write new configuration file.

type ConfigFileAlreadyExistsError string

// Error returns the formatted error when configuration already exists.

func (faee ConfigFileAlreadyExistsError) Error() string {

	return fmt.Sprintf("Config File %q Already Exists", string(faee))

}

// A DecoderConfigOption can be passed to viper.Unmarshal to configure

// mapstructure.DecoderConfig options

type DecoderConfigOption func(*mapstructure.DecoderConfig)

// DecodeHook returns a DecoderConfigOption which overrides the default

// DecoderConfig.DecodeHook value, the default is:

//

//  mapstructure.ComposeDecodeHookFunc(

//		mapstructure.StringToTimeDurationHookFunc(),

//		mapstructure.StringToSliceHookFunc(","),

//	)

func DecodeHook(hook mapstructure.DecodeHookFunc) DecoderConfigOption {

	return func(c *mapstructure.DecoderConfig) {

		c.DecodeHook = hook

	}

}

// Viper is a prioritized configuration registry. It

// maintains a set of configuration sources, fetches

// values to populate those, and provides them according

// to the source's priority.

// The priority of the sources is the following:

// 1. overrides

// 2. flags

// 3. env. variables

// 4. config file

// 5. key/value store

// 6. defaults

//

// For example, if values from the following sources were loaded:

//

//  Defaults : {

//  	"secret": "",

//  	"user": "default",

//  	"endpoint": "https://localhost"

//  }

//  Config : {

//  	"user": "root"

//  	"secret": "defaultsecret"

//  }

//  Env : {

//  	"secret": "somesecretkey"

//  }

//

// The resulting config will have the following values:

//

//	{

//		"secret": "somesecretkey",

//		"user": "root",

//		"endpoint": "https://localhost"

//	}

type Viper struct {

	// Delimiter that separates a list of keys

	// used to access a nested value in one go

	keyDelim string

	// A set of paths to look for the config file in

	configPaths []string

	// The filesystem to read config from.

	fs afero.Fs

	// A set of remote providers to search for the configuration

	remoteProviders []*defaultRemoteProvider

	// Name of file to look for inside the path

	configName        string

	configFile        string

	configType        string

	configPermissions os.FileMode

	envPrefix         string

	automaticEnvApplied bool

	envKeyReplacer      StringReplacer

	allowEmptyEnv       bool

	config         map[string]interface{}

	override       map[string]interface{}

	defaults       map[string]interface{}

	kvstore        map[string]interface{}

	pflags         map[string]FlagValue

	aliases        map[string]string

	typeByDefValue bool

	// Store read properties on the object so that we can write back in order with comments.

	// This will only be used if the configuration read is a properties file.

	properties *properties.Properties

	onConfigChange func(fsnotify.Event)

}

// New returns an initialized Viper instance.

func New() *Viper {

	v := new(Viper)

	v.keyDelim = "."

	v.configName = "config"

	v.configPermissions = os.FileMode(0644)

	v.fs = afero.NewOsFs()

	v.config = make(map[string]interface{})

	v.override = make(map[string]interface{})

	v.defaults = make(map[string]interface{})

	v.kvstore = make(map[string]interface{})

	v.pflags = make(map[string]FlagValue)

	v.aliases = make(map[string]string)

	v.typeByDefValue = false

	return v

}

// Option configures Viper using the functional options paradigm popularized by Rob Pike and Dave Cheney.

// If you're unfamiliar with this style,

// see https://commandcenter.blogspot.com/2014/01/self-referential-functions-and-design.html and

// https://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis.

type Option interface {

	apply(v *Viper)

}

type optionFunc func(v *Viper)

func (fn optionFunc) apply(v *Viper) {

	fn(v)

}

// KeyDelimiter sets the delimiter used for determining key parts.

// By default it's value is ".".

func KeyDelimiter(d string) Option {

	return optionFunc(func(v *Viper) {

		v.keyDelim = d

	})

}

// StringReplacer applies a set of replacements to a string.

type StringReplacer interface {

	// Replace returns a copy of s with all replacements performed.

	Replace(s string) string

}

// EnvKeyReplacer sets a replacer used for mapping environment variables to internal keys.

func EnvKeyReplacer(r StringReplacer) Option {

	return optionFunc(func(v *Viper) {

		v.envKeyReplacer = r

	})

}

// NewWithOptions creates a new Viper instance.

func NewWithOptions(opts ...Option) *Viper {

	v := New()

	for _, opt := range opts {

		opt.apply(v)

	}

	return v

}

// Reset is intended for testing, will reset all to default settings.

// In the public interface for the viper package so applications

// can use it in their testing as well.

func Reset() {

	v = New()

	SupportedExts = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop", "hcl", "dotenv", "env", "ini"}

}

type defaultRemoteProvider struct {

	provider      string

	endpoint      string

	path          string

	secretKeyring string

}

func (rp defaultRemoteProvider) Provider() string {

	return rp.provider

}

func (rp defaultRemoteProvider) Endpoint() string {

	return rp.endpoint

}

func (rp defaultRemoteProvider) Path() string {

	return rp.path

}

func (rp defaultRemoteProvider) SecretKeyring() string {

	return rp.secretKeyring

}

// RemoteProvider stores the configuration necessary

// to connect to a remote key/value store.

// Optional secretKeyring to unencrypt encrypted values

// can be provided.

type RemoteProvider interface {

	Provider() string

	Endpoint() string

	Path() string

	SecretKeyring() string

}

// SupportedExts are universally supported extensions.

var SupportedExts = []string{"json", "toml", "yaml", "yml", "properties", "props", "prop", "hcl", "dotenv", "env", "ini"}

// SupportedRemoteProviders are universally supported remote providers.

func OnConfigChange(run func(in fsnotify.Event)) { v.OnConfigChange(run) }

func (v *Viper) OnConfigChange(run func(in fsnotify.Event)) {

	v.onConfigChange = run

}

func WatchConfig() { v.WatchConfig() }

func (v *Viper) WatchConfig() {

	initWG := sync.WaitGroup{}

	initWG.Add(1)

	go func() {

		if err != nil {

			log.Fatal(err)

		}

		defer watcher.Close()

		// we have to watch the entire directory to pick up renames/atomic saves in a cross-platform way

		filename, err := v.getConfigFile()

		if err != nil {

			log.Printf("error: %v\n", err)

			initWG.Done()

			return

		}

		configFile := filepath.Clean(filename)

		configDir, _ := filepath.Split(configFile)

		realConfigFile, _ := filepath.EvalSymlinks(filename)

		eventsWG := sync.WaitGroup{}

		eventsWG.Add(1)

		go func() {

			for {

				select {

				case event, ok := <-watcher.Events:

					if !ok { // 'Events' channel is closed

						eventsWG.Done()

						return

					}

					currentConfigFile, _ := filepath.EvalSymlinks(filename)

					// we only care about the config file with the following cases:

					// 1 - if the config file was modified or created

					// 2 - if the real path to the config file changed (eg: k8s ConfigMap replacement)

					const writeOrCreateMask = fsnotify.Write | fsnotify.Create

					if (filepath.Clean(event.Name) == configFile &&

						event.Op&writeOrCreateMask != 0) ||

						(currentConfigFile != "" && currentConfigFile != realConfigFile) {

						realConfigFile = currentConfigFile

						err := v.ReadInConfig()

						if err != nil {

							log.Printf("error reading config file: %v\n", err)

						}

						if v.onConfigChange != nil {

							v.onConfigChange(event)

						}

					} else if filepath.Clean(event.Name) == configFile &&

						event.Op&fsnotify.Remove&fsnotify.Remove != 0 {

						eventsWG.Done()

						return

					}

				case err, ok := <-watcher.Errors:

					if ok { // 'Errors' channel is not closed

						log.Printf("watcher error: %v\n", err)

					}

					eventsWG.Done()

					return

				}

			}

		}()

		watcher.Add(configDir)

		initWG.Done()   // done initializing the watch in this go routine, so the parent routine can move on...

		eventsWG.Wait() // now, wait for event loop to end in this go-routine...

	}()

	initWG.Wait() // make sure that the go routine above fully ended before returning

}

// SetConfigFile explicitly defines the path, name and extension of the config file.

// Viper will use this and not check any of the config paths.

func SetConfigFile(in string) { v.SetConfigFile(in) }

func (v *Viper) SetConfigFile(in string) {

	if in != "" {

		v.configFile = in

	}

}

// SetEnvPrefix defines a prefix that ENVIRONMENT variables will use.

// E.g. if your prefix is "spf", the env registry will look for env