package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"
	"os"
	"os/exec"
	"path/filepath"

	"hacklab.nilfm.cc/quartzgun/renderer"
	"hacklab.nilfm.cc/quartzgun/router"
	. "hacklab.nilfm.cc/quartzgun/util"

	"forge.lightcrystal.systems/lightcrystal/memnarch/action"
	"forge.lightcrystal.systems/lightcrystal/memnarch/webhook"
)

func decode(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		data := make(map[string]interface{})

		err := json.NewDecoder(req.Body).Decode(&data)

		if err == nil {
			AddContextValue(req, "data", data)
		} else {
			AddContextValue(req, "data", err.Error())
		}

		next.ServeHTTP(w, req)
	})
}

func runJob(secret string, next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
		// validate signature
		_, err := webhook.Verify([]byte(secret), req)
		if err != nil {
			w.WriteHeader(422)
			return
		}
		// get repo from data
		data := req.Context().Value("data").(map[string]interface{})
		if data != nil {
			w.WriteHeader(500)
			return
		}
		repoUrl := data["repository"].(map[string]interface{})["clone_url"].(string)
		owner := data["owner"].(map[string]interface{})["login"].(string)
		repo := data["repository"].(map[string]interface{})["name"].(string)
		obj := data["head_commit"].(map[string]interface{})["id"].(string)

		// create working dir
		workingDir := filepath.Join("working", owner, repo, obj)
		if os.MkdirAll(workingDir, 0750) != nil {
			w.WriteHeader(500)
			return
		}

		// from this point on we can tell the client they succeeded

		// so we run the rest in a goroutine...
		go func() {
			// cd and checkout repo
			clone := exec.Command("git", "clone", repoUrl)
			clone.Dir = workingDir

			err := clone.Run()
			if err != nil {
				// clone error - log it and quit
				return
			}
			// read memnarch action file
			urlParams := req.Context().Value("params").(map[string]string)
			jobName := urlParams["job"]

			jobFile := filepath.Join(workingDir, repo, jobName+".yml")
			a, err := action.Read(jobFile)

			if err != nil {
				fmt.Println(err.Error())
			}

			// decode and perform action
			// build
			buildCmd := exec.Command(a.Build.Cmd)
			buildCmd.Dir = filepath.Join(workingDir, repo)

			// pre-deploy
			// deploy
			// post-deploy
		}()

		AddContextValue(req, "data", "job submitted")
		next.ServeHTTP(w, req)
	})
}

func seeJobsForRepo(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	})
}

func seeJobsForObject(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
	})
}

func run(args []string) error {
	secret := args[1]

	rtr := &router.Router{
		Fallback: *template.Must(template.ParseFiles("templates/error.html")),
	}

	rtr.Post("/echo", decode(renderer.JSON("data")))
	rtr.Post(`/do/(?P<job>\S+)`, decode(runJob(secret, renderer.JSON("data"))))
	rtr.Get(`/status/(?P<owner>[^/]+)/(?P<repo>\S+)`, seeJobsForRepo(renderer.JSON("data")))
	rtr.Get(`/status/(?P<owner>[^/]+)/(?P<repo>[^/]+)/(?P<object>\S+)`, seeJobsForObject(renderer.JSON("data")))

	http.ListenAndServe(":9999", rtr)
	return nil
}

func main() {
	err := run(os.Args)
	if err == nil {
		os.Exit(0)
	} else {
		fmt.Println(err.Error())
		os.Exit(1)
	}
}