package minecraft

import (
	"fmt"
	"regexp"
	"strconv"

	"github.com/influxdata/telegraf"
	"github.com/influxdata/telegraf/plugins/inputs"
)

const sampleConfig = `
  ## server address for minecraft
  # server = "localhost"
  ## port for RCON
  # port = "25575"
  ## password RCON for mincraft server
  # password = ""
`

var (
	playerNameRegex = regexp.MustCompile(`for\s([^:]+):-`)
	scoreboardRegex = regexp.MustCompile(`(?U):\s(\d+)\s\((.*)\)`)
)

// Client is an interface for a client which gathers data from a minecraft server
type Client interface {
	Gather(producer RCONClientProducer) ([]string, error)
}

// Minecraft represents a connection to a minecraft server
type Minecraft struct {
	Server    string
	Port      string
	Password  string
	client    Client
	clientSet bool
}

// Description gives a brief description.
func (s *Minecraft) Description() string {
	return "Collects scores from a minecraft server's scoreboard using the RCON protocol"
}

// SampleConfig returns our sampleConfig.
func (s *Minecraft) SampleConfig() string {
	return sampleConfig
}

// Gather uses the RCON protocal to collect player and
// scoreboard stats from a minecraft server.
//var hasClient bool = false
func (s *Minecraft) Gather(acc telegraf.Accumulator) error {
	// can't simply compare s.client to nil, because comparing an interface
	// to nil often does not produce the desired result
	if !s.clientSet {
		var err error
		s.client, err = NewRCON(s.Server, s.Port, s.Password)
		if err != nil {
			return err
		}
		s.clientSet = true
	}

	// (*RCON).Gather() takes an RCONClientProducer for testing purposes
	d := defaultClientProducer{
		Server: s.Server,
		Port:   s.Port,
	}

	scores, err := s.client.Gather(d)
	if err != nil {
		return err
	}

	for _, score := range scores {
		player, err := ParsePlayerName(score)
		if err != nil {
			return err
		}
		tags := map[string]string{
			"player": player,
			"server": s.Server + ":" + s.Port,
		}

		stats, err := ParseScoreboard(score)
		if err != nil {
			return err
		}
		var fields = make(map[string]interface{}, len(stats))
		for _, stat := range stats {
			fields[stat.Name] = stat.Value
		}

		acc.AddFields("minecraft", fields, tags)
	}

	return nil
}

// ParsePlayerName takes an input string from rcon, to parse
// the player.
func ParsePlayerName(input string) (string, error) {
	playerMatches := playerNameRegex.FindAllStringSubmatch(input, -1)
	if playerMatches == nil {
		return "", fmt.Errorf("no player was matched")
	}
	return playerMatches[0][1], nil
}

// Score is an individual tracked scoreboard stat.
type Score struct {
	Name  string
	Value int
}

// ParseScoreboard takes an input string from rcon, to parse
// scoreboard stats.
func ParseScoreboard(input string) ([]Score, error) {
	scoreMatches := scoreboardRegex.FindAllStringSubmatch(input, -1)
	if scoreMatches == nil {
		return nil, fmt.Errorf("No scores found")
	}

	var scores []Score

	for _, match := range scoreMatches {
		number := match[1]
		name := match[2]
		n, err := strconv.Atoi(number)
		// Not necessary in current state, because regex can only match integers,
		// maybe become necessary if regex is modified to match more types of
		// numbers
		if err != nil {
			return nil, fmt.Errorf("Failed to parse score")
		}
		s := Score{
			Name:  name,
			Value: n,
		}
		scores = append(scores, s)
	}
	return scores, nil
}

func init() {
	inputs.Add("minecraft", func() telegraf.Input {
		return &Minecraft{
			Server: "localhost",
			Port:   "25575",
		}
	})
}