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

	"errors"

	"fmt"

	"io"

	"log"

	"os"

	"path/filepath"

	"reflect"

	"strconv"

	"strings"

	"sync"

	"time"

	"github.com/fsnotify/fsnotify"

	"github.com/mitchellh/mapstructure"

	"github.com/spf13/afero"

	"github.com/spf13/cast"

	"github.com/spf13/pflag"

	"github.com/spf13/viper/internal/encoding"

	"github.com/spf13/viper/internal/encoding/dotenv"

	"github.com/spf13/viper/internal/encoding/hcl"

	"github.com/spf13/viper/internal/encoding/ini"

	"github.com/spf13/viper/internal/encoding/javaproperties"

	"github.com/spf13/viper/internal/encoding/json"

	"github.com/spf13/viper/internal/encoding/toml"

	"github.com/spf13/viper/internal/encoding/yaml"

)

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

//

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:

//

//

// The resulting config will have the following values:

//

//	{

//		"secret": "somesecretkey",

//		"user": "root",

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

//	}

//

// Note: Vipers are not safe for concurrent Get() and Set() operations.

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

	// Specific commands for ini parsing

	iniLoadOptions ini.LoadOptions

	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

	env            map[string][]string

	aliases        map[string]string

	typeByDefValue bool

	onConfigChange func(fsnotify.Event)

	logger Logger

	// TODO: should probably be protected with a mutex

	encoderRegistry *encoding.EncoderRegistry

	decoderRegistry *encoding.DecoderRegistry

}

// New returns an initialized Viper instance.

func New() *Viper {

	v := new(Viper)

	v.keyDelim = "."

	v.configName = "config"

	v.configPermissions = os.FileMode(0o644)

	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

	v.logger = jwwLogger{}

	v.resetEncoding()

	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)

	}

	v.resetEncoding()

	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", "tfvars", "dotenv", "env", "ini"}

}

// TODO: make this lazy initialization instead

func (v *Viper) resetEncoding() {

	encoderRegistry := encoding.NewEncoderRegistry()

	decoderRegistry := encoding.NewDecoderRegistry()

	{

		codec := yaml.Codec{}

		encoderRegistry.RegisterEncoder("yaml", codec)

		decoderRegistry.RegisterDecoder("yaml", codec)

		encoderRegistry.RegisterEncoder("yml", codec)

		decoderRegistry.RegisterDecoder("yml", codec)

	}

	{

		codec := json.Codec{}

		encoderRegistry.RegisterEncoder("json", codec)

		decoderRegistry.RegisterDecoder("json", codec)

	}

	{

		codec := toml.Codec{}

		encoderRegistry.RegisterEncoder("toml", codec)

		decoderRegistry.RegisterDecoder("toml", codec)

	}

	{

		codec := hcl.Codec{}

		encoderRegistry.RegisterEncoder("hcl", codec)

		decoderRegistry.RegisterDecoder("hcl", codec)

		encoderRegistry.RegisterEncoder("tfvars", codec)

		decoderRegistry.RegisterDecoder("tfvars", codec)

	}

	{

		codec := ini.Codec{

			KeyDelimiter: v.keyDelim,

			LoadOptions:  v.iniLoadOptions,

		}

		encoderRegistry.RegisterEncoder("ini", codec)

		decoderRegistry.RegisterDecoder("ini", codec)

	}

	{

		codec := &javaproperties.Codec{

			KeyDelimiter: v.keyDelim,

		}

		encoderRegistry.RegisterEncoder("properties", codec)

		decoderRegistry.RegisterDecoder("properties", codec)

		encoderRegistry.RegisterEncoder("props", codec)

		decoderRegistry.RegisterDecoder("props", codec)

		encoderRegistry.RegisterEncoder("prop", codec)

		decoderRegistry.RegisterDecoder("prop", codec)

	}

	{

		codec := &dotenv.Codec{}

		encoderRegistry.RegisterEncoder("dotenv", codec)

		decoderRegistry.RegisterDecoder("dotenv", codec)

		encoderRegistry.RegisterEncoder("env", codec)

		decoderRegistry.RegisterDecoder("env", codec)

	}

	v.encoderRegistry = encoderRegistry

	v.decoderRegistry = decoderRegistry

}

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", "tfvars", "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)) {