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

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

	"github.com/fsnotify/fsnotify"

	"github.com/hashicorp/hcl"

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

	"github.com/magiconair/properties"

	"github.com/mitchellh/mapstructure"

	"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

	automaticEnvApplied bool

	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

}

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

// can use it in their testing as well.

func Reset() {

	v = New()

	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.

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

			return

		}

		configFile := filepath.Clean(filename)

		configDir, _ := filepath.Split(configFile)

		go func() {

			for {

				select {

						}

					}

				}

			}

		}()

		watcher.Add(configDir)

	}()

}

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

	}

}