package config

import (
	//"github.com/davecgh/go-spew/spew"
	"encoding/base64"
	"encoding/json"
	"errors"
	"fmt"
	"log"
	"os"

	nodepb "github.com/gravitl/netmaker/grpc"
	"github.com/gravitl/netmaker/models"
	"github.com/urfave/cli/v2"
	"gopkg.in/yaml.v3"
)

type GlobalConfig struct {
	GRPCWireGuard string `yaml:"grpcwg"`
	Client        models.IntClient
}

type ClientConfig struct {
	Server          ServerConfig `yaml:"server"`
	Node            NodeConfig   `yaml:"node"`
	Network         string       `yaml:"network"`
	Daemon          string       `yaml:"daemon"`
	OperatingSystem string       `yaml:"operatingsystem"`
}
type ServerConfig struct {
	CoreDNSAddr   string `yaml:"corednsaddr"`
	GRPCAddress   string `yaml:"grpcaddress"`
	APIAddress    string `yaml:"apiaddress"`
	AccessKey     string `yaml:"accesskey"`
	GRPCSSL       string `yaml:"grpcssl"`
	GRPCWireGuard string `yaml:"grpcwg"`
}

type ListConfig struct {
	Name           string `yaml:"name"`
	Interface      string `yaml:"interface"`
	PrivateIPv4    string `yaml:"wgaddress"`
	PrivateIPv6    string `yaml:"wgaddress6"`
	PublicEndpoint string `yaml:"endpoint"`
}

type NodeConfig struct {
	Name             string `yaml:"name"`
	Interface        string `yaml:"interface"`
	Network          string `yaml:"network"`
	Password         string `yaml:"password"`
	MacAddress       string `yaml:"macaddress"`
	LocalAddress     string `yaml:"localaddress"`
	WGAddress        string `yaml:"wgaddress"`
	WGAddress6       string `yaml:"wgaddress6"`
	Roaming          string `yaml:"roaming"`
	DNS              string `yaml:"dns"`
	IsLocal          string `yaml:"islocal"`
	IsDualStack      string `yaml:"isdualstack"`
	IsIngressGateway string `yaml:"isingressgateway"`
	LocalRange       string `yaml:"localrange"`
	PostUp           string `yaml:"postup"`
	PostDown         string `yaml:"postdown"`
	Port             int32  `yaml:"port"`
	KeepAlive        int32  `yaml:"keepalive"`
	PublicKey        string `yaml:"publickey"`
	ServerPubKey     string `yaml:"serverpubkey"`
	PrivateKey       string `yaml:"privatekey"`
	Endpoint         string `yaml:"endpoint"`
	PostChanges      string `yaml:"postchanges"`
	StaticIP         string `yaml:"staticip"`
	StaticPubKey     string `yaml:"staticpubkey"`
	IPForwarding     string `yaml:"ipforwarding"`
	UDPHolePunch     string `yaml:"udpholepunch"`
	SaveConfig     string `yaml:"saveconfig"`
}

//reading in the env file
func Write(config *ClientConfig, network string) error {
	if network == "" {
		err := errors.New("No network provided. Exiting.")
		return err
	}
	_, err := os.Stat("/etc/netclient")
	if os.IsNotExist(err) {
		os.Mkdir("/etc/netclient", 744)
	} else if err != nil {
		return err
	}
	home := "/etc/netclient"

	file := fmt.Sprintf(home + "/netconfig-" + network)
	f, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	defer f.Close()

	err = yaml.NewEncoder(f).Encode(config)
	if err != nil {
		return err
	}
	return err
}

//reading in the env file
func WriteGlobal(config *GlobalConfig) error {
	_, err := os.Stat("/etc/netclient")
	if os.IsNotExist(err) {
		os.Mkdir("/etc/netclient", 744)
	} else if err != nil {
		return err
	}
	home := "/etc/netclient"

	if err != nil {
		log.Fatal(err)
	}
	file := fmt.Sprintf(home + "/netconfig-global-001")
	f, err := os.OpenFile(file, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, os.ModePerm)
	defer f.Close()

	err = yaml.NewEncoder(f).Encode(config)
	if err != nil {
		return err
	}
	return err
}
func WriteServer(server string, accesskey string, network string) error {
	if network == "" {
		err := errors.New("No network provided. Exiting.")
		return err
	}
	nofile := false
	//home, err := homedir.Dir()
	_, err := os.Stat("/etc/netclient")
	if os.IsNotExist(err) {
		os.Mkdir("/etc/netclient", 744)
	} else if err != nil {
		fmt.Println("couldnt find or create /etc/netclient")
		return err
	}
	home := "/etc/netclient"

	file := fmt.Sprintf(home + "/netconfig-" + network)
	//f, err := os.Open(file)
	f, err := os.OpenFile(file, os.O_CREATE|os.O_RDWR, 0666)
	//f, err := ioutil.ReadFile(file)
	if err != nil {
		fmt.Println("couldnt open netconfig-" + network)
		fmt.Println(err)
		nofile = true
		//err = nil
		return err
	}
	defer f.Close()

	//cfg := &ClientConfig{}
	var cfg ClientConfig

	if !nofile {
		fmt.Println("Writing to existing config file at " + home + "/netconfig-" + network)
		decoder := yaml.NewDecoder(f)
		err = decoder.Decode(&cfg)
		//err = yaml.Unmarshal(f, &cfg)
		if err != nil {
			//fmt.Println(err)
			//return err
		}
		f.Close()
		f, err = os.OpenFile(file, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
		if err != nil {
			fmt.Println("couldnt open netconfig")
			fmt.Println(err)
			nofile = true
			//err = nil
			return err
		}
		defer f.Close()

		if err != nil {
			fmt.Println("trouble opening file")
			fmt.Println(err)
		}

		cfg.Server.GRPCAddress = server
		cfg.Server.AccessKey = accesskey

		err = yaml.NewEncoder(f).Encode(cfg)
		//_, err = yaml.Marshal(f, &cfg)
		if err != nil {
			fmt.Println("trouble encoding file")
			return err
		}
	} else {
		fmt.Println("Creating new config file at " + home + "/netconfig-" + network)

		cfg.Server.GRPCAddress = server
		cfg.Server.AccessKey = accesskey

		newf, err := os.Create(home + "/netconfig-" + network)
		err = yaml.NewEncoder(newf).Encode(cfg)
		defer newf.Close()
		if err != nil {
			return err
		}
	}

	return err
}

func (config *ClientConfig) ReadConfig() {

	nofile := false
	//home, err := homedir.Dir()
	home := "/etc/netclient"
	file := fmt.Sprintf(home + "/netconfig-" + config.Network)
	//f, err := os.Open(file)
	f, err := os.OpenFile(file, os.O_RDONLY, 0666)
	if err != nil {
		fmt.Println("trouble opening file")
		fmt.Println(err)
		nofile = true
		//fmt.Println("Could not access " + home + "/.netconfig,  proceeding...")
	}
	defer f.Close()

	//var cfg ClientConfig

	if !nofile {
		decoder := yaml.NewDecoder(f)
		err = decoder.Decode(&config)
		if err != nil {
			fmt.Println("no config or invalid")
			fmt.Println(err)
			log.Fatal(err)
		} else {
			//config = cfg
		}
	}
}
func ModGlobalConfig(cfg models.IntClient) error {
	var modconfig GlobalConfig
	var err error
	if FileExists("/etc/netclient/netconfig-global-001") {
		useconfig, err := ReadGlobalConfig()
		if err != nil {
			return err
		}
		modconfig = *useconfig
	}
	if cfg.ServerWGPort != "" {
		modconfig.Client.ServerWGPort = cfg.ServerWGPort
	}
	if cfg.ServerGRPCPort != "" {
		modconfig.Client.ServerGRPCPort = cfg.ServerGRPCPort
	}
	if cfg.ServerAPIPort != "" {
		modconfig.Client.ServerAPIPort = cfg.ServerAPIPort
	}
	if cfg.PublicKey != "" {
		modconfig.Client.PublicKey = cfg.PublicKey
	}
	if cfg.PrivateKey != "" {
		modconfig.Client.PrivateKey = cfg.PrivateKey
	}
	if cfg.ServerPublicEndpoint != "" {
		modconfig.Client.ServerPublicEndpoint = cfg.ServerPublicEndpoint
	}
	if cfg.ServerPrivateAddress != "" {
		modconfig.Client.ServerPrivateAddress = cfg.ServerPrivateAddress
	}
	if cfg.Address != "" {
		modconfig.Client.Address = cfg.Address
	}
	if cfg.Address6 != "" {
		modconfig.Client.Address6 = cfg.Address6
	}
	if cfg.Network != "" {
		modconfig.Client.Network = cfg.Network
	}
	if cfg.ServerKey != "" {
		modconfig.Client.ServerKey = cfg.ServerKey
	}
	if cfg.AccessKey != "" {
		modconfig.Client.AccessKey = cfg.AccessKey
	}
	if cfg.ClientID != "" {
		modconfig.Client.ClientID = cfg.ClientID
	}
	err = WriteGlobal(&modconfig)
	return err
}

func ModConfig(node *nodepb.Node) error {
	network := node.Nodenetwork
	if network == "" {
		return errors.New("No Network Provided")
	}
	var modconfig ClientConfig
	var err error
	if FileExists("/etc/netclient/netconfig-" + network) {
		useconfig, err := ReadConfig(network)
		if err != nil {
			return err
		}
		modconfig = *useconfig
	}
	nodecfg := modconfig.Node
	if node.Name != "" {
		nodecfg.Name = node.Name
	}
	if node.Interface != "" {
		nodecfg.Interface = node.Interface
	}
	if node.Nodenetwork != "" {
		nodecfg.Network = node.Nodenetwork
	}
	if node.Macaddress != "" {
		nodecfg.MacAddress = node.Macaddress
	}
	if node.Localaddress != "" {
		nodecfg.LocalAddress = node.Localaddress
	}
	if node.Postup != "" {
		nodecfg.PostUp = node.Postup
	}
	if node.Postdown != "" {
		nodecfg.PostDown = node.Postdown
	}
	if node.Listenport != 0 {
		nodecfg.Port = node.Listenport
	}
	if node.Keepalive != 0 {
		nodecfg.KeepAlive = node.Keepalive
	}
	if node.Publickey != "" {
		nodecfg.PublicKey = node.Publickey
	}
	if node.Endpoint != "" {
		nodecfg.Endpoint = node.Endpoint
	}
	if node.Password != "" {
		nodecfg.Password = node.Password
	}
	if node.Address != "" {
		nodecfg.WGAddress = node.Address
	}
	if node.Address6 != "" {
		nodecfg.WGAddress6 = node.Address6
	}
	if node.Postchanges != "" {
		nodecfg.PostChanges = node.Postchanges
	}
	if node.Dnsoff == true {
		nodecfg.DNS = "off"
	}
	if node.Isdualstack == true {
		nodecfg.IsDualStack = "yes"
	}
	if node.Udpholepunch != "" {
		nodecfg.UDPHolePunch = node.Udpholepunch
	}
        if node.Saveconfig != "" {
                nodecfg.SaveConfig = node.Saveconfig
        }
	if node.Isingressgateway {
		nodecfg.IsIngressGateway = "yes"
	} else {
		nodecfg.IsIngressGateway = "no"
	}
	if node.Localrange != "" && node.Islocal {
		nodecfg.IsLocal = "yes"
		nodecfg.LocalRange = node.Localrange
	}
	modconfig.Node = nodecfg
	err = Write(&modconfig, network)
	return err
}

func GetCLIConfig(c *cli.Context) (ClientConfig, error) {
	var cfg ClientConfig
	if c.String("token") != "" {
		tokenbytes, err := base64.StdEncoding.DecodeString(c.String("token"))
		if err != nil {
			log.Println("error decoding token")
			return cfg, err
		}
		var accesstoken models.AccessToken
		if err := json.Unmarshal(tokenbytes, &accesstoken); err != nil {
			log.Println("error converting token json to object", tokenbytes)
			return cfg, err
		}

		if accesstoken.ServerConfig.APIConnString != "" {
			cfg.Server.APIAddress = accesstoken.ServerConfig.APIConnString
		} else {
			cfg.Server.APIAddress = accesstoken.ServerConfig.APIHost
			if accesstoken.ServerConfig.APIPort != "" {
				cfg.Server.APIAddress = cfg.Server.APIAddress + ":" + accesstoken.ServerConfig.APIPort
			}
		}
		if accesstoken.ServerConfig.GRPCConnString != "" {
			cfg.Server.GRPCAddress = accesstoken.ServerConfig.GRPCConnString
		} else {
			cfg.Server.GRPCAddress = accesstoken.ServerConfig.GRPCHost
			if accesstoken.ServerConfig.GRPCPort != "" {
				cfg.Server.GRPCAddress = cfg.Server.GRPCAddress + ":" + accesstoken.ServerConfig.GRPCPort
			}
		}
		cfg.Network = accesstoken.ClientConfig.Network
		cfg.Node.Network = accesstoken.ClientConfig.Network
		cfg.Server.AccessKey = accesstoken.ClientConfig.Key
		cfg.Node.LocalRange = accesstoken.ClientConfig.LocalRange
		cfg.Server.GRPCSSL = accesstoken.ServerConfig.GRPCSSL
		cfg.Server.GRPCWireGuard = accesstoken.WG.GRPCWireGuard
		cfg.Server.CoreDNSAddr = accesstoken.ServerConfig.CoreDNSAddr
		if c.String("grpcserver") != "" {
			cfg.Server.GRPCAddress = c.String("grpcserver")
		}
		if c.String("apiserver") != "" {
			cfg.Server.APIAddress = c.String("apiserver")
		}
		if c.String("key") != "" {
			cfg.Server.AccessKey = c.String("key")
		}
		if c.String("network") != "all" {
			cfg.Network = c.String("network")
			cfg.Node.Network = c.String("network")
		}
		if c.String("localrange") != "" {
			cfg.Node.LocalRange = c.String("localrange")
		}
		if c.String("grpcssl") != "" {
			cfg.Server.GRPCSSL = c.String("grpcssl")
		}
		if c.String("corednsaddr") != "" {
			cfg.Server.CoreDNSAddr = c.String("corednsaddr")
		}
		if c.String("grpcwg") != "" {
			cfg.Server.GRPCWireGuard = c.String("grpcwg")
		}

	} else {
		cfg.Server.GRPCAddress = c.String("grpcserver")
		cfg.Server.APIAddress = c.String("apiserver")
		cfg.Server.AccessKey = c.String("key")
		cfg.Network = c.String("network")
		cfg.Node.Network = c.String("network")
		cfg.Node.LocalRange = c.String("localrange")
		cfg.Server.GRPCWireGuard = c.String("grpcwg")
		cfg.Server.GRPCSSL = c.String("grpcssl")
		cfg.Server.CoreDNSAddr = c.String("corednsaddr")
	}
	cfg.Node.Name = c.String("name")
	cfg.Node.Interface = c.String("interface")
	cfg.Node.Password = c.String("password")
	cfg.Node.MacAddress = c.String("macaddress")
	cfg.Node.LocalAddress = c.String("localaddress")
	cfg.Node.WGAddress = c.String("address")
	cfg.Node.WGAddress6 = c.String("addressIPV6")
	cfg.Node.Roaming = c.String("roaming")
	cfg.Node.DNS = c.String("dns")
	cfg.Node.IsLocal = c.String("islocal")
	cfg.Node.IsDualStack = c.String("isdualstack")
	cfg.Node.PostUp = c.String("postup")
	cfg.Node.PostDown = c.String("postdown")
	cfg.Node.Port = int32(c.Int("port"))
	cfg.Node.KeepAlive = int32(c.Int("keepalive"))
	cfg.Node.PublicKey = c.String("publickey")
	cfg.Node.PrivateKey = c.String("privatekey")
	cfg.Node.Endpoint = c.String("endpoint")
	cfg.Node.IPForwarding = c.String("ipforwarding")
	cfg.OperatingSystem = c.String("operatingsystem")
	cfg.Daemon = c.String("daemon")
	cfg.Node.UDPHolePunch = c.String("udpholepunch")

	return cfg, nil
}

func GetCLIConfigRegister(c *cli.Context) (GlobalConfig, error) {
	var cfg GlobalConfig
	if c.String("token") != "" {
		tokenbytes, err := base64.StdEncoding.DecodeString(c.String("token"))
		if err != nil {
			log.Println("error decoding token")
			return cfg, err
		}
		var accesstoken models.AccessToken
		if err := json.Unmarshal(tokenbytes, &accesstoken); err != nil {
			log.Println("error converting token json to object", tokenbytes)
			return cfg, err
		}
		cfg.GRPCWireGuard = accesstoken.WG.GRPCWireGuard
		cfg.Client.ServerPrivateAddress = accesstoken.WG.GRPCWGAddress
		cfg.Client.ServerGRPCPort = accesstoken.WG.GRPCWGPort
		if err != nil {
			log.Println("error decoding token grpcserver")
			return cfg, err
		}
		if err != nil {
			log.Println("error decoding token apiserver")
			return cfg, err
		}
		if accesstoken.ServerConfig.APIConnString != "" {
			cfg.Client.ServerPublicEndpoint = accesstoken.ServerConfig.APIConnString
		} else {
			cfg.Client.ServerPublicEndpoint = accesstoken.ServerConfig.APIHost
			if accesstoken.ServerConfig.APIPort != "" {
				cfg.Client.ServerAPIPort = accesstoken.ServerConfig.APIPort
			}
		}
		cfg.Client.ServerWGPort = accesstoken.WG.GRPCWGPort
		cfg.Client.ServerKey = accesstoken.ClientConfig.Key
		cfg.Client.ServerKey = accesstoken.WG.GRPCWGPubKey

		if c.String("grpcserver") != "" {
			cfg.Client.ServerPrivateAddress = c.String("grpcserver")
		}
		if c.String("apiserver") != "" {
			cfg.Client.ServerPublicEndpoint = c.String("apiserver")
		}
		if c.String("pubkey") != "" {
			cfg.Client.ServerKey = c.String("pubkey")
		}
		if c.String("network") != "all" {
			cfg.Client.Network = c.String("network")
		}
	} else {
		cfg.Client.ServerPrivateAddress = c.String("grpcserver")
		cfg.Client.ServerPublicEndpoint = c.String("apiserver")
		cfg.Client.ServerKey = c.String("key")
		cfg.Client.Network = c.String("network")
	}
	cfg.Client.Address = c.String("address")
	cfg.Client.Address6 = c.String("addressIPV6")
	cfg.Client.PublicKey = c.String("pubkey")
	cfg.Client.PrivateKey = c.String("privkey")

	return cfg, nil
}

func ReadConfig(network string) (*ClientConfig, error) {
	if network == "" {
		err := errors.New("No network provided. Exiting.")
		return nil, err
	}
	nofile := false
	home := "/etc/netclient"
	file := fmt.Sprintf(home + "/netconfig-" + network)
	f, err := os.Open(file)

	if err != nil {
		nofile = true
	}
	defer f.Close()

	var cfg ClientConfig

	if !nofile {
		decoder := yaml.NewDecoder(f)
		err = decoder.Decode(&cfg)
		if err != nil {
			fmt.Println("trouble decoding file")
			return nil, err
		}
	}
	return &cfg, err
}

func ReadGlobalConfig() (*GlobalConfig, error) {
	nofile := false
	home := "/etc/netclient"
	file := fmt.Sprintf(home + "/netconfig-global-001")
	f, err := os.Open(file)

	if err != nil {
		nofile = true
	}
	defer f.Close()

	var cfg GlobalConfig

	if !nofile {
		decoder := yaml.NewDecoder(f)
		err = decoder.Decode(&cfg)
		if err != nil {
			fmt.Println("trouble decoding file")
			return nil, err
		}
	}
	return &cfg, err
}

func FileExists(f string) bool {
	info, err := os.Stat(f)
	if os.IsNotExist(err) {
		return false
	}
	return !info.IsDir()
}