package config

import (
	"sync"
	"time"
)

type Config interface {
	Get(key string) interface{}
	GetBool(key string) bool
	GetFloat64(key string) float64
	GetInt(key string) int
	GetString(key string) string
	GetStringMap(key string) map[string]interface{}
	GetStringMapString(key string) map[string]string
	GetStringSlice(key string) []string
	GetTime(key string) time.Time
	IsSet(key string) bool
	Set(key string, value interface{})
}

type MapConfig map[string]interface{}

func (cfg MapConfig) Get(key string) interface{}    { return cfg[key] }
func (cfg MapConfig) GetBool(key string) bool       { return cfg[key].(bool) }
func (cfg MapConfig) GetFloat64(key string) float64 { return cfg[key].(float64) }
func (cfg MapConfig) GetInt(key string) int         { return cfg[key].(int) }
func (cfg MapConfig) GetString(key string) string   { return cfg[key].(string) }
func (cfg MapConfig) GetStringMap(key string) map[string]interface{} {
	return cfg[key].(map[string]interface{})
}
func (cfg MapConfig) GetStringMapString(key string) map[string]string {
	return cfg[key].(map[string]string)
}
func (cfg MapConfig) GetStringSlice(key string) []string { return cfg[key].([]string) }
func (cfg MapConfig) GetTime(key string) time.Time       { return cfg[key].(time.Time) }
func (cfg MapConfig) IsSet(key string) bool              { _, ok := cfg[key]; return ok }
func (cfg MapConfig) Set(key string, value interface{})  { cfg[key] = value }
func (cfg MapConfig) SetDefault(key string, value interface{}) {
	if cfg.IsSet(key) {
		return
	}
	cfg[key] = value
}

//--------------------------------------------------------------------------------
// A little convenient hack to notify listeners upon config changes.

type Configurable func(Config)

var mtx sync.Mutex
var globalConfig Config
var confs []Configurable

func OnConfig(conf func(Config)) {
	mtx.Lock()
	defer mtx.Unlock()

	confs = append(confs, conf)
	if globalConfig != nil {
		conf(globalConfig)
	}
}

func ApplyConfig(config Config) {
	mtx.Lock()
	globalConfig = config
	confsCopy := make([]Configurable, len(confs))
	copy(confsCopy, confs)
	mtx.Unlock()

	for _, conf := range confsCopy {
		conf(config)
	}
}