/*
* Copyright 2022-present Open Networking Foundation
* 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 main

import (
	"strconv"
	"strings"

	"voltha-go-controller/internal/pkg/util/envutils"
)

// RW Core service default constants
const (
	defaultLogLevel                  = "DEBUG"
	defaultVolthaHost                = "127.0.0.1"
	defaultVolthaPort                = 50057
	defaultProbeHost                 = ""
	defaultProbePort                 = 8090
	defaultBanner                    = true
	defaultDisplayVersion            = false
	defaultCPUProfile                = ""
	defaultMemProfile                = ""
	defaultDeviceListRefreshInterval = 10
	defaultDeviceSyncDuration        = 5
	defaultMaxFlowRetryDuration      = 60
	/*
		FIXME(At RWCORE) Problem: VGC comes up fast by that time RWCORE may not be up and will retry after 10 sec
		but rwcore could come up before the 10 second expiry and post indications to VGC which can't be consumed by
		VGC. Proper workaround is heml to sping VGC only when RWCORE reports via prope when the grpc server is up
		OR maintain a event/indiction queue similar to that in openolt-agent(which too is a GRPC SERVER)
		WorkAround: Reduce retry interval to 1 second from existing 10 seconds to that chances of indications getting missed is rare
	*/
	defaultConnectionRetryDelay = 1
	defaultConnectionMaxRetries = 120
	defaultKVStoreType          = "etcd"
	defaultKVStoreHost          = "127.0.0.1"
	defaultKVStorePort          = 2379
	defaultKVStoreTimeout       = 5000000000
	defaultKafkaAdapterHost     = "127.0.0.1"
	defaultKafkaAdapterPort     = 9092
	defaultInstanceID           = "VGC-01"
	defaultVendorID             = ""
)

func newVGCFlags() *VGCFlags {
	var vgcConfig = VGCFlags{
		LogLevel:                  defaultLogLevel,
		VolthaHost:                defaultVolthaHost,
		VolthaPort:                defaultVolthaPort,
		KVStoreType:               defaultKVStoreType,
		KVStoreHost:               defaultKVStoreHost,
		KVStorePort:               defaultKVStorePort,
		KVStoreTimeout:            defaultKVStoreTimeout,
		KafkaAdapterHost:          defaultKafkaAdapterHost,
		KafkaAdapterPort:          defaultKafkaAdapterPort,
		ProbeHost:                 defaultProbeHost,
		ProbePort:                 defaultProbePort,
		Banner:                    defaultBanner,
		DisplayVersion:            defaultDisplayVersion,
		CPUProfile:                defaultCPUProfile,
		MemProfile:                defaultMemProfile,
		DeviceListRefreshInterval: defaultDeviceListRefreshInterval,
		ConnectionRetryDelay:      defaultConnectionRetryDelay,
		ConnectionMaxRetries:      defaultConnectionMaxRetries,
		InstanceID:                defaultInstanceID,
		VendorID:                  defaultVendorID,
		DeviceSyncDuration:        defaultDeviceSyncDuration,
	}

	return &vgcConfig
}

// VGCFlags represents the set of configurations used by the VGC service
type VGCFlags struct {
	LogLevel                  string
	VolthaHost                string
	InstanceID                string
	KVStoreEndPoint           string
	MsgBusEndPoint            string
	ProbeEndPoint             string
	VolthaAPIEndPoint         string
	VendorID                  string
	KVStoreType               string
	KVStoreHost               string
	KafkaAdapterHost          string
	ProbeHost                 string
	CPUProfile                string
	MemProfile                string
	OFControllerEndPoints     multiFlag
	KafkaAdapterPort          int
	KVStoreTimeout            int // in seconds
	KVStorePort               int
	VolthaPort                int
	ProbePort                 int
	DeviceListRefreshInterval int // in seconds
	ConnectionRetryDelay      int // in seconds
	ConnectionMaxRetries      int
	DeviceSyncDuration        int // Time interval between each cycle of audit task
	MaxFlowRetryDuration      int // Maximum duration for which flows will be retried upon failures
	Banner                    bool
	DisplayVersion            bool
}

// parseEnvironmentVariables parses the arguments when running read-write VGC service
func (cf *VGCFlags) parseEnvironmentVariables() {
	cf.LogLevel = envutils.ParseStringEnvVariable(envutils.LogLevel, defaultLogLevel)
	cf.VolthaHost = envutils.ParseStringEnvVariable(envutils.VolthaHost, defaultVolthaHost)
	cf.VolthaPort = int(envutils.ParseIntEnvVariable(envutils.VolthaPort, defaultVolthaPort))
	cf.KVStoreType = envutils.ParseStringEnvVariable(envutils.KvStoreType, defaultKVStoreType)
	cf.KVStoreTimeout = int(envutils.ParseIntEnvVariable(envutils.KvStoreTimeout, defaultKVStoreTimeout))
	cf.KVStoreHost = envutils.ParseStringEnvVariable(envutils.KvStoreHost, defaultKVStoreHost)
	cf.KVStorePort = int(envutils.ParseIntEnvVariable(envutils.KvStorePort, defaultKVStorePort))
	cf.KafkaAdapterHost = envutils.ParseStringEnvVariable(envutils.KafkaAdapterHost, defaultKafkaAdapterHost)
	cf.KafkaAdapterPort = int(envutils.ParseIntEnvVariable(envutils.KafkaAdapterPort, defaultKafkaAdapterPort))
	cf.ProbeHost = envutils.ParseStringEnvVariable(envutils.ProbeHost, defaultProbeHost)
	cf.ProbePort = int(envutils.ParseIntEnvVariable(envutils.ProbePort, defaultProbePort))
	cf.Banner = envutils.ParseBoolEnvVariable(envutils.Banner, defaultBanner)
	cf.DisplayVersion = envutils.ParseBoolEnvVariable(envutils.DisplayVersionOnly, defaultDisplayVersion)
	cf.CPUProfile = envutils.ParseStringEnvVariable(envutils.CPUProfile, defaultCPUProfile)
	cf.MemProfile = envutils.ParseStringEnvVariable(envutils.MemProfile, defaultMemProfile)
	cf.DeviceListRefreshInterval = int(envutils.ParseIntEnvVariable(envutils.DeviceListRefreshInterval, defaultDeviceListRefreshInterval))
	cf.ConnectionRetryDelay = int(envutils.ParseIntEnvVariable(envutils.ConnectionRetryInterval, defaultConnectionRetryDelay))
	cf.ConnectionMaxRetries = int(envutils.ParseIntEnvVariable(envutils.MaxConnectionRetries, defaultConnectionMaxRetries))
	cf.InstanceID = envutils.ParseStringEnvVariable(envutils.HostName, defaultInstanceID)
	cf.VendorID = envutils.ParseStringEnvVariable(envutils.VendorID, defaultVendorID)

	cf.KVStoreEndPoint = cf.KVStoreHost + ":" + strconv.Itoa(cf.KVStorePort)
	cf.MsgBusEndPoint = cf.KafkaAdapterHost + ":" + strconv.Itoa(cf.KafkaAdapterPort)
	cf.ProbeEndPoint = cf.ProbeHost + ":" + strconv.Itoa(cf.ProbePort)
	cf.VolthaAPIEndPoint = cf.VolthaHost + ":" + strconv.Itoa(cf.VolthaPort)

	cf.DeviceSyncDuration = int(envutils.ParseIntEnvVariable(envutils.DeviceSyncDuration, defaultDeviceSyncDuration))
	cf.MaxFlowRetryDuration = int(envutils.ParseIntEnvVariable(envutils.MaxFlowRetryDuration, defaultMaxFlowRetryDuration))
}

type multiFlag []string

func (m *multiFlag) String() string {
	return "[" + strings.Join(*m, ", ") + "]"
}

func (m *multiFlag) Set(value string) error {
	*m = append(*m, value)
	return nil
}

/*
func parseCommandLineArguments() (*VGCFlags, error) {
	config := VGCFlags{}

	flag.BoolVar(&(config.Banner),
		"banner",
		true,
		"display application banner on startup")
	flag.BoolVar(&(config.DisplayVersion),
		"version",
		false,
		"display application version and exit")
	flag.StringVar(&(config.VolthaAPIEndPoint),
		"voltha",
		"127.0.0.1:50057",
		"connection to the VOLTHA API server specified as host:port")
	flag.StringVar(&(config.VolthaAPIEndPoint),
		"A",
		"127.0.0.1:50057",
		"(short) connection to the VOLTHA API server specified as host:port")
	flag.StringVar(&(config.ProbeEndPoint),
		"probe",
		":50080",
		"address and port on which to listen for k8s live and ready probe requests")
	flag.StringVar(&(config.ProbeEndPoint),
		"P",
		":50080",
		"(short) address and port on which to listen for k8s live and ready probe requests")
	flag.StringVar(&(config.CPUProfile),
		"cpuprofile",
		"",
		"write cpu profile to 'file' if specified")
	flag.StringVar(&(config.MemProfile),
		"memprofile",
		"",
		"write memory profile to 'file' if specified")
	flag.IntVar(&(config.ConnectionRetryDelay),
		"cd",
		3,
		"(short) delay to wait before connection establishment retries")
	flag.IntVar(&(config.ConnectionRetryDelay),
		"connnection-delay",
		3,
		"delay to wait before connection establishment retries")
	flag.IntVar(&(config.ConnectionMaxRetries),
		"mr",
		0,
		"(short) number of retries when attempting to estblish a connection, 0 is unlimted")
	flag.IntVar(&(config.ConnectionMaxRetries),
		"connnection-retries",
		0,
		"number of retries when attempting to estblish a connection, 0 is unlimted")
	flag.IntVar(&(config.DeviceListRefreshInterval),
		"dri",
		10,
		"(short) interval between attempts to synchronize devices from voltha to vpagent")
	flag.IntVar(&(config.DeviceListRefreshInterval),
		"device-refresh-interval",
		10,
		"interval between attempts to synchronize devices from voltha to vpagent")
	flag.StringVar(&(config.KVStoreType), "kv_store_type", "etcd", "KV store type")

	flag.IntVar(&(config.KVStoreTimeout), "kv_store_request_timeout", 5, "The default timeout when making a kv store request")

	flag.StringVar(&(config.KVStoreHost), "kv_store_host", "127.0.0.1", "KV store host")

	flag.IntVar(&(config.KVStorePort), "kv_store_port", 2379, "KV store port")

	flag.StringVar(&(config.MsgBusEndPoint), "msgbus_addr", "127.0.0.1:9092", "msgbus address")

	flag.StringVar(&(config.LogLevel), "log_level", "DEBUG", "Log level")

	containerName := getContainerInfo()
	if len(containerName) > 0 {
		config.InstanceID = containerName
	} else {
		config.InstanceID = "VGC-01"
	}

	return &config, nil
}

func getContainerInfo() string {
	return os.Getenv("HOSTNAME")
}*/