/*
Copyright 2020 The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package common

import (
	"fmt"
	"os"
	gofilepath "path/filepath"
	"strconv"

	"gopkg.in/yaml.v3"
)

// Config is the internal representation of the yaml that defines
// server configuration.
type Config struct {
	RuntimeEndpoint   string
	ImageEndpoint     string
	Timeout           int
	Debug             bool
	PullImageOnCreate bool
	DisablePullOnRun  bool
	yamlData          *yaml.Node // YAML representation of config
}

// ReadConfig reads from a file with the given name and returns a config or
// an error if the file was unable to be parsed.
func ReadConfig(filepath string) (*Config, error) {
	data, err := os.ReadFile(filepath)
	if err != nil {
		return nil, err
	}
	yamlConfig := &yaml.Node{}
	err = yaml.Unmarshal(data, yamlConfig)
	if err != nil {
		return nil, err
	}
	config, err := getConfigOptions(yamlConfig)
	if err != nil {
		return nil, err
	}
	return config, err
}

// WriteConfig writes config to file
// an error if the file was unable to be written to.
func WriteConfig(c *Config, filepath string) error {
	if c == nil {
		c = new(Config)
		c.yamlData = new(yaml.Node)
	}

	setConfigOptions(c)

	data, err := yaml.Marshal(c.yamlData)
	if err != nil {
		return err
	}

	if err := os.MkdirAll(gofilepath.Dir(filepath), 0o755); err != nil {
		return err
	}
	return os.WriteFile(filepath, data, 0o644)
}

// Extracts config options from the yaml data which is loaded from file.
func getConfigOptions(yamlData *yaml.Node) (*Config, error) {
	config := &Config{yamlData: yamlData}

	if yamlData.Content == nil || len(yamlData.Content) == 0 ||
		yamlData.Content[0].Content == nil {
		return config, nil
	}
	contentLen := len(yamlData.Content[0].Content)

	// YAML representation contains 2 yaml ScalarNodes per config option.
	// One is config option name and other is the value of the option
	// These ScalarNodes help preserve comments associated with
	// the YAML entry
	for indx := 0; indx < contentLen-1; {
		configOption := yamlData.Content[0].Content[indx]
		name := configOption.Value
		value := yamlData.Content[0].Content[indx+1].Value
		var err error
		switch name {
		case "runtime-endpoint":
			config.RuntimeEndpoint = value
		case "image-endpoint":
			config.ImageEndpoint = value
		case "timeout":
			config.Timeout, err = strconv.Atoi(value)
			if err != nil {
				return nil, fmt.Errorf("parsing config option '%s': %w", name, err)
			}
		case "debug":
			config.Debug, err = strconv.ParseBool(value)
			if err != nil {
				return nil, fmt.Errorf("parsing config option '%s': %w", name, err)
			}
		case "pull-image-on-create":
			config.PullImageOnCreate, err = strconv.ParseBool(value)
			if err != nil {
				return nil, fmt.Errorf("parsing config option '%s': %w", name, err)
			}
		case "disable-pull-on-run":
			config.DisablePullOnRun, err = strconv.ParseBool(value)
			if err != nil {
				return nil, fmt.Errorf("parsing config option '%s': %w", name, err)
			}
		default:
			return nil, fmt.Errorf("Config option '%s' is not valid", name)
		}
		indx += 2
	}

	return config, nil
}

// Set config options on yaml data for persistece to file.
func setConfigOptions(config *Config) {
	setConfigOption("runtime-endpoint", config.RuntimeEndpoint, config.yamlData)
	setConfigOption("image-endpoint", config.ImageEndpoint, config.yamlData)
	setConfigOption("timeout", strconv.Itoa(config.Timeout), config.yamlData)
	setConfigOption("debug", strconv.FormatBool(config.Debug), config.yamlData)
	setConfigOption("pull-image-on-create", strconv.FormatBool(config.PullImageOnCreate), config.yamlData)
	setConfigOption("disable-pull-on-run", strconv.FormatBool(config.DisablePullOnRun), config.yamlData)
}

// Set config option on yaml.
func setConfigOption(configName, configValue string, yamlData *yaml.Node) {
	if yamlData.Content == nil || len(yamlData.Content) == 0 {
		yamlData.Kind = yaml.DocumentNode
		yamlData.Content = make([]*yaml.Node, 1)
		yamlData.Content[0] = &yaml.Node{
			Kind: yaml.MappingNode,
			Tag:  "!!map",
		}
	}
	contentLen := 0
	foundOption := false
	if yamlData.Content[0].Content != nil {
		contentLen = len(yamlData.Content[0].Content)
	}

	// Set value on existing config option
	for indx := 0; indx < contentLen-1; {
		name := yamlData.Content[0].Content[indx].Value
		if name == configName {
			yamlData.Content[0].Content[indx+1].Value = configValue
			foundOption = true
			break
		}
		indx += 2
	}

	// New config option to set
	// YAML representation contains 2 yaml ScalarNodes per config option.
	// One is config option name and other is the value of the option
	// These ScalarNodes help preserve comments associated with
	// the YAML entry
	if !foundOption {
		const (
			tagPrefix = "!!"
			tagStr    = tagPrefix + "str"
			tagBool   = tagPrefix + "bool"
			tagInt    = tagPrefix + "int"
		)
		name := &yaml.Node{
			Kind:  yaml.ScalarNode,
			Value: configName,
			Tag:   tagStr,
		}
		var tagType string
		switch configName {
		case "timeout":
			tagType = tagInt
		case "debug":
			tagType = tagBool
		case "pull-image-on-create":
			tagType = tagBool
		case "disable-pull-on-run":
			tagType = tagBool
		default:
			tagType = tagStr
		}

		value := &yaml.Node{
			Kind:  yaml.ScalarNode,
			Value: configValue,
			Tag:   tagType,
		}
		yamlData.Content[0].Content = append(yamlData.Content[0].Content, name, value)
	}
}
