// 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 a 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"

	"fmt"

	"io"

	"log"

	"os"

	"path/filepath"

	"reflect"

	"strings"

	"time"

	yaml "gopkg.in/yaml.v2"

	"github.com/fsnotify/fsnotify"

	"github.com/hashicorp/hcl"

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

	"github.com/magiconair/properties"

	"github.com/mitchellh/mapstructure"

	toml "github.com/pelletier/go-toml"

	"github.com/spf13/afero"

	"github.com/spf13/cast"

	jww "github.com/spf13/jwalterweatherman"

	"github.com/spf13/pflag"

)

// 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)

}

// 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

	envPrefix  string

	automaticEnvApplied bool

	envKeyReplacer      *strings.Replacer

	config         map[string]interface{}

	override       map[string]interface{}

	defaults       map[string]interface{}

	kvstore        map[string]interface{}

	pflags         map[string]FlagValue

	env            map[string]string

	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.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.env = make(map[string]string)

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

	v.typeByDefValue = false

	return v

}

// 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"}

	SupportedRemoteProviders = []string{"etcd", "consul"}

}

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"}

// SupportedRemoteProviders are universally supported remote providers.

var SupportedRemoteProviders = []string{"etcd", "consul"}

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() {

	go func() {

		watcher, err := fsnotify.NewWatcher()

		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.Println("error:", err)

			return

		}

		configFile := filepath.Clean(filename)

		configDir, _ := filepath.Split(configFile)

		done := make(chan bool)

		go func() {

			for {

				select {

				case event := <-watcher.Events:

					// we only care about the config file

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

						if event.Op&fsnotify.Write == fsnotify.Write || event.Op&fsnotify.Create == fsnotify.Create {

							err := v.ReadInConfig()

							if err != nil {

								log.Println("error:", err)

							}

							if v.onConfigChange != nil {

								v.onConfigChange(event)

							}

						}

					}

				case err := <-watcher.Errors:

					log.Println("error:", err)

				}

			}

		}()

		watcher.Add(configDir)

		<-done

	}()

}

// 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

// variables that start with "SPF_".

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

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

	if in != "" {

		v.envPrefix = in

	}

}

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

	if v.envPrefix != "" {

		return strings.ToUpper(v.envPrefix + "_" + in)

	}

	return strings.ToUpper(in)

}

// TODO: should getEnv logic be moved into find(). Can generalize the use of

// rewriting keys many things, Ex: Get('someKey') -> some_key

// (camel case to snake case for JSON keys perhaps)

// getEnv is a wrapper around os.Getenv which replaces characters in the original

// key. This allows env vars which have different keys than the config object

// keys.

func (v *Viper) getEnv(key string) string {

	if v.envKeyReplacer != nil {

		key = v.envKeyReplacer.Replace(key)

	}

	return os.Getenv(key)

}

// ConfigFileUsed returns the file used to populate the config registry.

func ConfigFileUsed() string            { return v.ConfigFileUsed() }

func (v *Viper) ConfigFileUsed() string { return v.configFile }

// AddConfigPath adds a path for Viper to search for the config file in.

// Can be called multiple times to define multiple search paths.

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

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

	if in != "" {

		absin := absPathify(in)

		jww.INFO.Println("adding", absin, "to paths to search")

		if !stringInSlice(absin, v.configPaths) {

			v.configPaths = append(v.configPaths, absin)

		}

	}

}

// AddRemoteProvider adds a remote configuration source.

// Remote Providers are searched in the order they are added.

// provider is a string value, "etcd" or "consul" are currently supported.

// endpoint is the url.  etcd requires http://ip:port  consul requires ip:port

// path is the path in the k/v store to retrieve configuration

// To retrieve a config file called myapp.json from /configs/myapp.json

// you should set path to /configs and set config name (SetConfigName()) to

// "myapp"

func AddRemoteProvider(provider, endpoint, path string) error {

	return v.AddRemoteProvider(provider, endpoint, path)

}

func (v *Viper) AddRemoteProvider(provider, endpoint, path string) error {

	if !stringInSlice(provider, SupportedRemoteProviders) {

		return UnsupportedRemoteProviderError(provider)

	}

	if provider != "" && endpoint != "" {

		jww.INFO.Printf("adding %s:%s to remote provider list", provider, endpoint)

		rp := &defaultRemoteProvider{

			endpoint: endpoint,

			provider: provider,

			path:     path,

		}

		if !v.providerPathExists(rp) {

			v.remoteProviders = append(v.remoteProviders, rp)

		}

	}

	return nil

}

// AddSecureRemoteProvider adds a remote configuration source.

// Secure Remote Providers are searched in the order they are added.

// provider is a string value, "etcd" or "consul" are currently supported.

// endpoint is the url.  etcd requires http://ip:port  consul requires ip:port

// secretkeyring is the filepath to your openpgp secret keyring.  e.g. /etc/secrets/myring.gpg

// path is the path in the k/v store to retrieve configuration

// To retrieve a config file called myapp.json from /configs/myapp.json

// you should set path to /configs and set config name (SetConfigName()) to

// "myapp"

// Secure Remote Providers are implemented with github.com/xordataexchange/crypt

func AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {

	return v.AddSecureRemoteProvider(provider, endpoint, path, secretkeyring)

}

func (v *Viper) AddSecureRemoteProvider(provider, endpoint, path, secretkeyring string) error {

	if !stringInSlice(provider, SupportedRemoteProviders) {

		return UnsupportedRemoteProviderError(provider)

	}

	if provider != "" && endpoint != "" {