package main

import (
	"flag"
	"fmt"
	"html/template"
	"io/ioutil"
	"log"
	"net/http"
	"strings"

	"github.com/gorilla/mux"
)

var (
	port *int
)

func registerHTTPFlags() {
	port = flag.Int("port", 8080, "The port for HTTP")
}

func setupHTTPServer() http.Server {
	r := mux.NewRouter()

	r.HandleFunc("/", indexHandler)
	r.HandleFunc("/create", createGetHandler).Methods("GET")
	r.HandleFunc("/create", createPostHandler).Methods("POST")
	r.HandleFunc("/view", viewGetHandler).Methods("GET")
	r.HandleFunc("/edit", editGetHandler).Methods("GET")
	r.HandleFunc("/edit", editPostHandler).Methods("POST")

	return http.Server{
		Addr:    fmt.Sprintf("0.0.0.0:%d", *port),
		Handler: r,
	}
}

// Host the index file
func indexHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "%s", "Hello World!\n")
}

func createGetHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("create GET")
	readFileToResponse(w, "/create.html")
}

// createPostHandler handles HTTP POST requests to the /create endpoint creating
// new challenges in the database
func createPostHandler(w http.ResponseWriter, r *http.Request) {

	// parse the Post Request form
	r.ParseForm()

	// Define the new challenge
	newChallenge := Challenge{
		Name:        r.Form.Get("challengeName"),
		Description: r.Form.Get("challengeDescription"),
		Flag:        r.Form.Get("challengeFlag"),
		Container:   r.Form.Get("challengeContainer"),
		Category:    r.Form.Get("challengeCategory"),
		Points:      r.Form.Get("challengePoints"),
		Static:      r.Form.Get("challengeStatic"),
	}

	// Create the new challenge in the database
	err := newChallenge(newChallenge)
	if err != nil {
		log.Println(err)
	}
}

// viewGetHandler returns a list of all challenges in the database
func viewGetHandler(w http.ResponseWriter, r *http.Request) {
	// get all challenges from the db
	challs := getAllChallenges(db)

	// define a challenges struct storing the challenges.
	// This struct can be used in a template
	challenges := Challenges{}

	for _, chal := range challs {
		challenges.Challenge = append(challenges.Challenge, chal)
	}

	// define a new template to render the challenges in
	t := template.New("")
	t, err := t.ParseFiles("./hosted/view.html")
	if err != nil {
		log.Println(err)
		return
	}

	// execure the template using the challenges struct
	t.ExecuteTemplate(w, "view", challenges)
}

func editGetHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("edit GET")
	readFileToResponse(w, "/edit.html")
}

func editPostHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("edit POST")

}

// Helper function to host files off of "hosted/" directory
func readFileToResponse(w http.ResponseWriter, path string) {
	requestedFile := strings.Replace(path, "..", "", -1)

	contents, readError := ioutil.ReadFile(fmt.Sprintf("hosted/%s", requestedFile))

	if readError != nil {
		w.Write([]byte(fmt.Sprintf("unable to read %s", requestedFile)))
	} else {
		w.Write([]byte(contents))
	}
}