package vpn

import (
	"context"

	ctrlclient "sigs.k8s.io/controller-runtime/pkg/client"

	v1cluster "edge-infra.dev/pkg/edge/apis/cluster/v1alpha1"
	"edge-infra.dev/pkg/sds/remoteaccess/constants"
	v1vpnconfig "edge-infra.dev/pkg/sds/remoteaccess/k8s/apis/vpnconfigs/v1"
	"edge-infra.dev/pkg/sds/remoteaccess/wireguard/client"
	"edge-infra.dev/pkg/sds/remoteaccess/wireguard/relay"
	"edge-infra.dev/pkg/sds/remoteaccess/wireguard/store"
)

var vpnConfigMapKey = ctrlclient.ObjectKey{
	Namespace: constants.VPNNamespace,
	Name:      constants.VPNConfigMapName,
}

type VPN struct {
	SubnetCIDR             string
	AvailableIPAddressPool IPAddressPool

	relay  *relay.Relay
	client *client.Client

	stores map[string]*store.Store // map of cluster edge id's to store config
}

func New() (*VPN, error) {
	return &VPN{
		SubnetCIDR:             "",
		AvailableIPAddressPool: nil,
		relay:                  nil,
		client:                 nil,
		stores:                 map[string]*store.Store{},
	}, nil
}

// The banners subnet, configured by a ConfigMap
func (v *VPN) GetSubnetCIDR() string {
	return v.SubnetCIDR
}

// Wireguard relay configuration object
func (v *VPN) Relay() *relay.Relay {
	return v.relay
}

func (v *VPN) Client() *client.Client {
	return v.client
}

// The store configuration objects
func (v *VPN) Stores() map[string]*store.Store {
	return v.stores
}

// The store configuration object with a given cluster ID
func (v *VPN) Store(clusterEdgeID string) *store.Store {
	return v.stores[clusterEdgeID]
}

// Checks if the banner has a store with a given cluster ID
func (v *VPN) HasStore(clusterEdgeID string) bool {
	_, ok := v.stores[clusterEdgeID]
	return ok
}

// Attempts to get the relay instance from its associated K8s secret.
// A new instance will be created if the K8s secret does not exist.
func (v *VPN) UpdateRelay(ctx context.Context, c ctrlclient.Client) error {
	relayWG, err := relay.Get(ctx, c)
	if err != nil {
		return err
	}
	v.relay = relayWG
	return nil
}

// Attempts to get the client instance from its associated K8s secret.
// A new instance will be created if the K8s secret does not exist.
func (v *VPN) UpdateClient(ctx context.Context, c ctrlclient.Client) error {
	clientWG, err := client.Get(ctx, c)
	if err != nil {
		return err
	}
	v.client = clientWG
	return nil
}

func (v *VPN) UpdateStore(ctx context.Context, c ctrlclient.Client, vpnConfig *v1vpnconfig.VPNConfig, cluster *v1cluster.Cluster) error {
	storeWG, err := store.Get(ctx, c, vpnConfig, cluster)
	if err != nil {
		return err
	}
	v.stores[vpnConfig.ClusterEdgeID()] = storeWG

	v.Store(vpnConfig.ClusterEdgeID()).SetEnabled(vpnConfig.IsEnabled())
	return v.Store(vpnConfig.ClusterEdgeID()).UpdateIPAddress(ctx, c, constants.StoreName, cluster.ObjectMeta.Name, vpnConfig.IP())
}

// Removes a store with given IP address from the banner
func (v *VPN) RemoveStore(clusterEdgeID string) {
	if v.HasStore(clusterEdgeID) {
		store := v.Store(clusterEdgeID)
		delete(v.stores, clusterEdgeID)
		v.setIPAddressAvailable(store.GetIPAddress())
	}
}