package main

import (
	"github.com/hashicorp/consul/api"
	"text/template"
	"bytes"
	"github.com/BurntSushi/toml"
	"strings"
	"github.com/BurntSushi/ty/fun"
	"net/http"
)


type Key struct {
	Value string
}

type ConsulProvider struct {
	Watch        bool
	Endpoint     string
	Prefix       string
	Filename     string
	consulClient *api.Client
}
var kvClient *api.KV

var ConsulFuncMap = template.FuncMap{
	"List": func(keys ...string) []string {
		joinedKeys := strings.Join(keys, "")
		keysPairs, _, err := kvClient.Keys(joinedKeys, "/", nil)
		if err != nil {
			log.Error("Error getting keys ", joinedKeys, err)
			return nil
		}
		keysPairs = fun.Filter(func(key string) bool {
			if (key == joinedKeys) {
				return false
			}
			return true
		}, keysPairs).([]string)
		return keysPairs
	},
	"Get": func(keys ...string) string {
		joinedKeys := strings.Join(keys, "")
		keyPair, _, err := kvClient.Get(joinedKeys, nil)
		if err != nil {
			log.Error("Error getting key ", joinedKeys, err)
			return ""
		}
		return string(keyPair.Value)
	},
	"Last": func(key string) string {
		splittedKey := strings.Split(key, "/")
		return splittedKey[len(splittedKey) -2]
	},
}

func NewConsulProvider() *ConsulProvider {
	consulProvider := new(ConsulProvider)
	// default values
	consulProvider.Watch = true
	consulProvider.Prefix = "traefik"

	return consulProvider
}

func (provider *ConsulProvider) Provide(configurationChan chan <- *Configuration) {
	config := &api.Config{
		Address:    provider.Endpoint,
		Scheme:     "http",
		HttpClient: http.DefaultClient,
	}
	consulClient, _ := api.NewClient(config)
	provider.consulClient = consulClient
	if provider.Watch {
		var waitIndex uint64
		keypairs, meta, err := consulClient.KV().Keys("", "", nil)
		if keypairs == nil && err == nil {
			log.Error("Key was not found.")
		}
		waitIndex = meta.LastIndex
		go func() {
			for {
				opts := api.QueryOptions{
					WaitIndex: waitIndex,
				}
				keypairs, meta, err := consulClient.KV().Keys("", "", &opts)
				if keypairs == nil && err == nil {
					log.Error("Key  was not found.")
				}
				waitIndex = meta.LastIndex
				configuration := provider.loadConsulConfig()
				if configuration != nil {
					configurationChan <- configuration
				}
			}
		}()
	}
	configuration := provider.loadConsulConfig()
	configurationChan <- configuration
}

func (provider *ConsulProvider) loadConsulConfig() *Configuration {
	configuration := new(Configuration)
	services := []*api.CatalogService{}
	kvClient = provider.consulClient.KV()

	servicesName, _, _ := provider.consulClient.Catalog().Services(nil)
	for serviceName, _ := range servicesName {
		catalogServices, _, _ := provider.consulClient.Catalog().Service(serviceName, "", nil)
		for _, catalogService := range catalogServices {
			services= append(services, catalogService)
		}
	}

	templateObjects := struct {
		Services []*api.CatalogService
	}{
		services,
	}

	tmpl := template.New(provider.Filename).Funcs(ConsulFuncMap)
	if len(provider.Filename) > 0 {
		_, err := tmpl.ParseFiles(provider.Filename)
		if err != nil {
			log.Error("Error reading file", err)
			return nil
		}
	} else {
		buf, err := Asset("providerTemplates/consul.tmpl")
		if err != nil {
			log.Error("Error reading file", err)
		}
		_, err = tmpl.Parse(string(buf))
		if err != nil {
			log.Error("Error reading file", err)
			return nil
		}
	}

	var buffer bytes.Buffer

	err := tmpl.Execute(&buffer, templateObjects)
	if err != nil {
		log.Error("Error with consul template:", err)
		return nil
	}

	if _, err := toml.Decode(buffer.String(), configuration); err != nil {
		log.Error("Error creating consul configuration:", err)
		return nil
	}

	return configuration
}