// Copyright 2015 The Prometheus 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.

// +build !nowireguard
// +build linux freebsd openbsd dragonfly darwin

package collector

import (
	"strconv"
	"time"

	"github.com/go-kit/kit/log"
	"github.com/prometheus/client_golang/prometheus"
	"golang.zx2c4.com/wireguard/wgctrl"
)

func init() {
	registerCollector("wireguard", defaultDisabled, NewWireguardCollector)
}

func NewWireguardCollector(logger log.Logger) (Collector, error) {
	subsystem := "wireguard"
	labels := []string{"name", "peer_key", "local_key", "endpoint", "version"}

	wg, err := wgctrl.New()
	if err != nil {
		return nil, err
	}

	return &wireguardCollector{
		client: wg,
		lastHandshakeSeconds: prometheus.NewDesc(
			prometheus.BuildFQName(namespace, subsystem, "last_handshake_secs"),
			"Wireguard last handshake seconds ago",
			labels, nil,
		),
		bytesIn: prometheus.NewDesc(
			prometheus.BuildFQName(namespace, subsystem, "bytes_in"),
			"Wireguard bytes in for connection",
			labels, nil,
		),
		bytesOut: prometheus.NewDesc(
			prometheus.BuildFQName(namespace, subsystem, "bytes_out"),
			"Wireguard bytes out for connection",
			labels, nil,
		),
	}, nil
}

type wireguardCollector struct {
	client               *wgctrl.Client
	lastHandshakeSeconds *prometheus.Desc
	bytesIn, bytesOut    *prometheus.Desc
}

func (c *wireguardCollector) Update(ch chan<- prometheus.Metric) error {
	devs, err := c.client.Devices()
	if err != nil {
		return err
	}

	for _, dev := range devs {
		for _, peer := range dev.Peers {
			labels := []string{
				dev.Name,
				peer.PublicKey.String(),
				dev.PublicKey.String(),
				peer.Endpoint.String(),
				strconv.Itoa(peer.ProtocolVersion),
			}

			ch <- prometheus.MustNewConstMetric(
				c.bytesIn, prometheus.CounterValue,
				float64(peer.ReceiveBytes),
				labels...,
			)
			ch <- prometheus.MustNewConstMetric(
				c.bytesOut, prometheus.CounterValue,
				float64(peer.TransmitBytes),
				labels...,
			)
			ch <- prometheus.MustNewConstMetric(
				c.lastHandshakeSeconds, prometheus.GaugeValue,
				float64(time.Now().Sub(peer.LastHandshakeTime).Seconds()),
				labels...,
			)
		}
	}

	return nil
}