package server

import (
	//"golang.org/x/crypto/bcrypt"
	//"net/http"
	"context"
	"encoding/json"

	"git.giftfish.de/ston1th/haproxy-lb/pkg/api/types"
	"git.giftfish.de/ston1th/haproxy-lb/pkg/api/v1/schema"
	"git.giftfish.de/ston1th/haproxy-lb/pkg/cluster"
)

func authHandler(h types.CtxHandler) types.CtxHandler {
	return func(ctx *types.Context) {
		// TODO
		// test:123456
		// test:$2b$10$zNfGTAQ94vifj2wtGsv1W.yZRe4/rDBzQixpB6FbrTed4BnHuNqBS
		//bcrypt.CompareHashAndPassword(hash, pw)
		h(ctx)
	}
}

func healthzHandler(ctx *types.Context) {
	// TODO maybe report etcd/raft stats
	ctx.OK()
}

func name(c, n string) string {
	return c + "/" + n
}

func lbname(c, n string) string {
	return c + "_" + n
}

func lbHandler(ctx *types.Context) {
	cl := ctx.Var("cluster")
	n := ctx.Var("name")
	name := name(cl, n)
	switch ctx.Method() {
	case "GET":
		b, err := ctx.Data.DB.GetLB(name)
		if err != nil {
			ctx.Log.Error(err, "error reading loadbalancer", "cluster", cl, "name", n)
			if err == cluster.ErrKeyNotFound {
				ctx.Err(types.ErrNotFound)
				return
			}
			ctx.Err(types.ErrISE)
			return
		}
		ctx.Body(b)
	case "POST":
		// TODO
		// handle if loadbalancer already exists
		// decode existing LB and read Name + IP from there
		b, err := ctx.ReadBody()
		if err != nil {
			ctx.Log.Error(err, "error reading request body", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		var lb schema.LoadBalancer
		err = json.Unmarshal(b, &lb)
		if err != nil {
			ctx.Log.Error(err, "error decoding request body", "cluster", cl, "name", n)
			ctx.Err(types.ErrInvalid)
			return
		}
		lb.Name = lbname(cl, n)
		lb.IP, err = ctx.Data.Alloc.AllocIP(context.Background(), name)
		if err != nil {
			ctx.Log.Error(err, "error allocating IP for loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		err = lb.Validate()
		if err != nil {
			ctx.Log.Error(err, "error validating loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrInvalid)
			return
		}
		b, err = lb.JSON()
		if err != nil {
			ctx.Log.Error(err, "error encoding loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		err = ctx.Data.DB.SetLB(name, b)
		if err != nil {
			ctx.Log.Error(err, "error writing loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		ctx.OK()
	case "DELETE":
		err := ctx.Data.Alloc.FreeIP(context.Background(), name)
		if err != nil {
			ctx.Log.Error(err, "error freeing IP of loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		err = ctx.Data.DB.DeleteLB(name)
		if err != nil {
			ctx.Log.Error(err, "error deleting loadbalancer", "cluster", cl, "name", n)
			ctx.Err(types.ErrISE)
			return
		}
		ctx.OK()
	}
}

func lbList(lbs map[string][]byte) (m map[string]json.RawMessage) {
	m = make(map[string]json.RawMessage)
	for k, v := range lbs {
		m[k] = json.RawMessage(v)
	}
	return
}

func lbClusterListHandler(ctx *types.Context) {
	cl := ctx.Var("cluster")
	m, err := ctx.Data.DB.GetLBs(cl)
	if err != nil {
		ctx.Log.Error(err, "error reading loadbalancers")
		ctx.Err(types.ErrISE)
		return
	}
	ctx.JSON(lbList(m))
}
func lbListHandler(ctx *types.Context) {
	m, err := ctx.Data.DB.GetLBs("")
	if err != nil {
		ctx.Log.Error(err, "error reading loadbalancers")
		ctx.Err(types.ErrISE)
		return
	}
	ctx.JSON(lbList(m))
}