package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"os"
	"time"

	fractal "git.lattuga.net/blallo/gotools/formatting"
	"git.lattuga.net/boyska/circolog"
	"github.com/gorilla/mux"
)

func setupHTTPCtl(hub circolog.Hub, verbose, debug bool) *mux.Router {
	m := mux.NewRouter()
	m.HandleFunc("/pause/toggle", togglePause(hub, verbose, debug)).Methods("POST")
	m.HandleFunc("/filter", setFilter(hub, verbose, debug)).Methods("POST")
	m.HandleFunc("/status", getStatus(hub, verbose, debug)).Methods("GET")
	m.HandleFunc("/logs/clear", clearQueue(hub, verbose)).Methods("POST")
	m.HandleFunc("/help", printHelp(verbose)).Methods("GET")
	m.HandleFunc("/echo", echo(verbose)).Methods("GET")
	return m
}

func getStatus(hub circolog.Hub, verbose, debug bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		response := make(chan circolog.CommandResponse)
		hub.Commands <- circolog.HubFullCommand{
			Command:  circolog.CommandStatus,
			Response: response,
		}
		resp := <-response
		w.Header().Set("content-type", "application/json")
		enc := json.NewEncoder(w)
		enc.Encode(map[string]interface{}{"status": resp.Value})
	}
}

func togglePause(hub circolog.Hub, verbose, debug bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if verbose {
			log.Printf("[%s] %s - toggled pause", r.Method, r.RemoteAddr)
		}
		r.ParseForm()
		waitTimePar := r.FormValue("waitTime")
		var waitTime time.Duration
		var err error
		if waitTimePar != "" {
			waitTime, err = time.ParseDuration(waitTimePar)
			if err != nil {
				w.WriteHeader(400)
				fmt.Fprintln(w, "waitTime not understood:", waitTimePar)
				return
			}
		}
		if debug {
			fmt.Println("[DEBUG] waitTime:", waitTime)
		}
		response := make(chan circolog.CommandResponse)
		hub.Commands <- circolog.HubFullCommand{
			Command:    circolog.CommandPauseToggle,
			Response:   response,
			Parameters: map[string]interface{}{"waitTime": waitTime},
		}
		resp := <-response
		active := resp.Value.(bool)
		w.Header().Set("content-type", "application/json")
		enc := json.NewEncoder(w)
		enc.Encode(map[string]interface{}{"paused": !active})
	}
}

func setFilter(hub circolog.Hub, verbose, debug bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		r.ParseForm()
		where := r.FormValue("where")
		response := make(chan circolog.CommandResponse)
		hub.Commands <- circolog.HubFullCommand{
			Command:    circolog.CommandNewFilter,
			Response:   response,
			Parameters: map[string]interface{}{"where": where},
		}
		resp := <-response
		if !resp.Value.(map[string]interface{})["success"].(bool) {
			w.WriteHeader(400)
		}
		w.Header().Set("content-type", "application/json")
		enc := json.NewEncoder(w)
		enc.Encode(resp.Value)
	}
}

func clearQueue(hub circolog.Hub, verbose bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if verbose {
			log.Printf("[%s] %s - cleared queue", r.Method, r.RemoteAddr)
		}
		response := make(chan circolog.CommandResponse)
		hub.Commands <- circolog.HubFullCommand{Command: circolog.CommandClear, Response: response}
		resp := <-response
		success := resp.Value.(bool)
		w.Header().Set("content-type", "application/json")
		enc := json.NewEncoder(w)
		enc.Encode(map[string]interface{}{"success": success})
	}
}

func printHelp(verbose bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if verbose {
			log.Printf("[%s] %s - asked for help", r.Method, r.RemoteAddr)
		}
		w.Header().Set("content-type", "application/json")
		enc := json.NewEncoder(w)
		var pathsWithDocs = map[string]string{
			"/pause/toggle": "Toggle the server from pause state (not listening)",
			"/logs/clear":   "Wipe the buffer from all the messages",
			"/status":       "Get info on the status of the server",
			"/help":         "This help",
			"/echo":         "Answers to heartbeat",
		}
		fractal.EncodeJSON(pathsWithDocs, enc)
		if verbose {
			errEnc := json.NewEncoder(os.Stderr)
			fractal.EncodeJSON(pathsWithDocs, errEnc)
		}
	}
}

func echo(verbose bool) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		log.Println("Echo")
		if verbose {
			log.Printf("[%s] %s - asked for echo", r.Method, r.RemoteAddr)
		}
		w.Header().Set("content-type", "text/plain")
		fmt.Fprintln(w, "I am on!")
	}
}