// Copyright 2018 Frank Schroeder. All rights reserved.

// Use of this source code is governed by a BSD-style

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

package properties

// BUG(frank): Set() does not check for invalid unicode literals since this is currently handled by the lexer.

// BUG(frank): Write() does not allow to configure the newline character. Therefore, on Windows LF is used.

import (

	"bytes"

	"fmt"

	"io"

	"log"

	"os"

	"regexp"

	"sort"

	"strconv"

	"strings"

	"time"

	"unicode/utf8"

)

const maxExpansionDepth = 64

// ErrorHandlerFunc defines the type of function which handles failures

// of the MustXXX() functions. An error handler function must exit

// the application after handling the error.

type ErrorHandlerFunc func(error)

// ErrorHandler is the function which handles failures of the MustXXX()

// functions. The default is LogFatalHandler.

var ErrorHandler ErrorHandlerFunc = LogFatalHandler

// LogHandlerFunc defines the function prototype for logging errors.

type LogHandlerFunc func(fmt string, args ...interface{})

// LogPrintf defines a log handler which uses log.Printf.

var LogPrintf LogHandlerFunc = log.Printf

// LogFatalHandler handles the error by logging a fatal error and exiting.

func LogFatalHandler(err error) {

	log.Fatal(err)

}

// PanicHandler handles the error by panicking.

func PanicHandler(err error) {

	panic(err)

}

// -----------------------------------------------------------------------------

// A Properties contains the key/value pairs from the properties input.

// All values are stored in unexpanded form and are expanded at runtime

type Properties struct {

	// Pre-/Postfix for property expansion.

	Prefix  string

	Postfix string

	// DisableExpansion controls the expansion of properties on Get()

	// and the check for circular references on Set(). When set to

	// true Properties behaves like a simple key/value store and does

	// not check for circular references on Get() or on Set().

	DisableExpansion bool

	// Stores the key/value pairs

	m map[string]string

	// Stores the comments per key.

	c map[string][]string

	// Stores the keys in order of appearance.

	k []string

	// WriteSeparator specifies the separator of key and value while writing the properties.

	WriteSeparator string

}

// NewProperties creates a new Properties struct with the default

// configuration for "${key}" expressions.

func NewProperties() *Properties {

	return &Properties{

		Prefix:  "${",

		Postfix: "}",

		m:       map[string]string{},

		c:       map[string][]string{},

		k:       []string{},

	}

}

// Load reads a buffer into the given Properties struct.

func (p *Properties) Load(buf []byte, enc Encoding) error {

	l := &Loader{Encoding: enc, DisableExpansion: p.DisableExpansion}

	newProperties, err := l.LoadBytes(buf)

	if err != nil {

		return err

	}

	p.Merge(newProperties)

	return nil

}

// Get returns the expanded value for the given key if exists.

// Otherwise, ok is false.

func (p *Properties) Get(key string) (value string, ok bool) {

	v, ok := p.m[key]

	if p.DisableExpansion {

		return v, ok

	}

	if !ok {

		return "", false

	}

	expanded, err := p.expand(key, v)

	// we guarantee that the expanded value is free of

	// circular references and malformed expressions

	// so we panic if we still get an error here.

	if err != nil {

		ErrorHandler(err)

	}

	return expanded, true

}

// MustGet returns the expanded value for the given key if exists.

// Otherwise, it panics.

func (p *Properties) MustGet(key string) string {

	if v, ok := p.Get(key); ok {

		return v

	}

	ErrorHandler(invalidKeyError(key))

	panic("ErrorHandler should exit")

}

// ----------------------------------------------------------------------------

// ClearComments removes the comments for all keys.

func (p *Properties) ClearComments() {

	p.c = map[string][]string{}

}

// ----------------------------------------------------------------------------

// GetComment returns the last comment before the given key or an empty string.

func (p *Properties) GetComment(key string) string {

	comments, ok := p.c[key]

	if !ok || len(comments) == 0 {

		return ""

	}

	return comments[len(comments)-1]

}

// ----------------------------------------------------------------------------

// GetComments returns all comments that appeared before the given key or nil.

func (p *Properties) GetComments(key string) []string {

	if comments, ok := p.c[key]; ok {

		return comments

	}

	return nil

}

// ----------------------------------------------------------------------------

// SetComment sets the comment for the key.

func (p *Properties) SetComment(key, comment string) {

	p.c[key] = []string{comment}

}

// ----------------------------------------------------------------------------

// SetComments sets the comments for the key. If the comments are nil then

// all comments for this key are deleted.

func (p *Properties) SetComments(key string, comments []string) {

	if comments == nil {

		delete(p.c, key)

		return

	}

	p.c[key] = comments

}

// ----------------------------------------------------------------------------

// GetBool checks if the expanded value is one of '1', 'yes',

// 'true' or 'on' if the key exists. The comparison is case-insensitive.

// If the key does not exist the default value is returned.

func (p *Properties) GetBool(key string, def bool) bool {

	v, err := p.getBool(key)

	if err != nil {

		return def

	}

	return v

}

// MustGetBool checks if the expanded value is one of '1', 'yes',

// 'true' or 'on' if the key exists. The comparison is case-insensitive.

// If the key does not exist the function panics.

func (p *Properties) MustGetBool(key string) bool {

	v, err := p.getBool(key)

	if err != nil {

		ErrorHandler(err)

	}

	return v

}

func (p *Properties) getBool(key string) (value bool, err error) {

	if v, ok := p.Get(key); ok {

		return boolVal(v), nil

	}

	return false, invalidKeyError(key)

}

func boolVal(v string) bool {

	v = strings.ToLower(v)

	return v == "1" || v == "true" || v == "yes" || v == "on"

}

// ----------------------------------------------------------------------------

// GetDuration parses the expanded value as an time.Duration (in ns) if the

// key exists. If key does not exist or the value cannot be parsed the default

// value is returned. In almost all cases you want to use GetParsedDuration().

func (p *Properties) GetDuration(key string, def time.Duration) time.Duration {

	v, err := p.getInt64(key)

	if err != nil {

		return def

	}

	return time.Duration(v)

}

// MustGetDuration parses the expanded value as an time.Duration (in ns) if

// the key exists. If key does not exist or the value cannot be parsed the

// function panics. In almost all cases you want to use MustGetParsedDuration().

func (p *Properties) MustGetDuration(key string) time.Duration {

	v, err := p.getInt64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return time.Duration(v)

}

// ----------------------------------------------------------------------------

// GetParsedDuration parses the expanded value with time.ParseDuration() if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned.

func (p *Properties) GetParsedDuration(key string, def time.Duration) time.Duration {

	s, ok := p.Get(key)

	if !ok {

		return def

	}

	v, err := time.ParseDuration(s)

	if err != nil {

		return def

	}

	return v

}

// MustGetParsedDuration parses the expanded value with time.ParseDuration() if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

func (p *Properties) MustGetParsedDuration(key string) time.Duration {

	s, ok := p.Get(key)

	if !ok {

		ErrorHandler(invalidKeyError(key))

	}

	v, err := time.ParseDuration(s)

	if err != nil {

		ErrorHandler(err)

	}

	return v

}

// ----------------------------------------------------------------------------

// GetFloat64 parses the expanded value as a float64 if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned.

func (p *Properties) GetFloat64(key string, def float64) float64 {

	v, err := p.getFloat64(key)

	if err != nil {

		return def

	}

	return v

}

// MustGetFloat64 parses the expanded value as a float64 if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

func (p *Properties) MustGetFloat64(key string) float64 {

	v, err := p.getFloat64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return v

}

func (p *Properties) getFloat64(key string) (value float64, err error) {

	if v, ok := p.Get(key); ok {

		value, err = strconv.ParseFloat(v, 64)

		if err != nil {

			return 0, err

		}

		return value, nil

	}

	return 0, invalidKeyError(key)

}

// ----------------------------------------------------------------------------

// GetInt parses the expanded value as an int if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned. If the value does not fit into an int the

// function panics with an out of range error.

func (p *Properties) GetInt(key string, def int) int {

	v, err := p.getInt64(key)

	if err != nil {

		return def

	}

	return intRangeCheck(key, v)

}

// MustGetInt parses the expanded value as an int if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

// If the value does not fit into an int the function panics with

// an out of range error.

func (p *Properties) MustGetInt(key string) int {

	v, err := p.getInt64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return intRangeCheck(key, v)

}

// ----------------------------------------------------------------------------

// GetInt64 parses the expanded value as an int64 if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned.

func (p *Properties) GetInt64(key string, def int64) int64 {

	v, err := p.getInt64(key)

	if err != nil {

		return def

	}

	return v

}

// MustGetInt64 parses the expanded value as an int if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

func (p *Properties) MustGetInt64(key string) int64 {

	v, err := p.getInt64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return v

}

func (p *Properties) getInt64(key string) (value int64, err error) {

	if v, ok := p.Get(key); ok {

		value, err = strconv.ParseInt(v, 10, 64)

		if err != nil {

			return 0, err

		}

		return value, nil

	}

	return 0, invalidKeyError(key)

}

// ----------------------------------------------------------------------------

// GetUint parses the expanded value as an uint if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned. If the value does not fit into an int the

// function panics with an out of range error.

func (p *Properties) GetUint(key string, def uint) uint {

	v, err := p.getUint64(key)

	if err != nil {

		return def

	}

	return uintRangeCheck(key, v)

}

// MustGetUint parses the expanded value as an int if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

// If the value does not fit into an int the function panics with

// an out of range error.

func (p *Properties) MustGetUint(key string) uint {

	v, err := p.getUint64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return uintRangeCheck(key, v)

}

// ----------------------------------------------------------------------------

// GetUint64 parses the expanded value as an uint64 if the key exists.

// If key does not exist or the value cannot be parsed the default

// value is returned.

func (p *Properties) GetUint64(key string, def uint64) uint64 {

	v, err := p.getUint64(key)

	if err != nil {

		return def

	}

	return v

}

// MustGetUint64 parses the expanded value as an int if the key exists.

// If key does not exist or the value cannot be parsed the function panics.

func (p *Properties) MustGetUint64(key string) uint64 {

	v, err := p.getUint64(key)

	if err != nil {

		ErrorHandler(err)

	}

	return v

}

func (p *Properties) getUint64(key string) (value uint64, err error) {

	if v, ok := p.Get(key); ok {

		value, err = strconv.ParseUint(v, 10, 64)

		if err != nil {

			return 0, err

		}

		return value, nil

	}

	return 0, invalidKeyError(key)

}