package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"net/http"
	"os/exec"
	"time"
)

var templates = make(map[string]*template.Template, 3)

func loadTemplates() {
	templateNames := [1]string{"index"}
	for index, name := range templateNames {
		t, err := template.ParseFiles("layout.html", name+".html")
		if err == nil {
			templates[name] = t
			fmt.Println("Loaded template", index, name)
		} else {
			panic(err)
		}
	}
}

func indexHandler(w http.ResponseWriter, request *http.Request) {
	if request.URL.Path == "/" {
		proliantIsAlive := pingServer("server.rodley.net")
		oracleIsAlive := oracleServerUp()

		statuses := struct {
			ProliantIsAlive bool
			OracleIsAlive   bool
		}{ProliantIsAlive: proliantIsAlive, OracleIsAlive: oracleIsAlive}

		fmt.Println("Statuses:", statuses)
		templates["index"].Execute(w, statuses)
	} else {
		w.WriteHeader(http.StatusNotFound)
		w.Header().Set("Content-Type", "application/json")
		resp := make(map[string]string)
		resp["message"] = "Resource Not Found"
		jsonResp, err := json.Marshal(resp)
		if err != nil {
			fmt.Println("Error happened in JSON marshal", err)
		}
		w.Write(jsonResp)
	}
}

func pingServer(serverName string) bool {
	cmd := exec.Command("ping", "-c 1", serverName)
	fmt.Printf("Running ping and waiting for it to finish...\n")
	err := cmd.Run()
	if err == nil {
		return true
	} else {
		return false
	}
}

func oracleServerUp() bool {
	return portOpen("oracle.rodley.net", "1521")
}

func portOpen(serverName string, port string) bool {
	command := "nmap " + serverName + " | grep " + port
	fmt.Println(command)

	cmd := exec.Command("bash", "-c", command)
	fmt.Printf("Running nmap looking for the open port...\n")
	err := cmd.Run()
	if err == nil {
		return true
	} else {
		fmt.Println("Err", err)
		return false
	}
}

func powerOnOracle() bool {
	cmd := exec.Command("bash", "-c", "./start_oracle.sh")
	err := cmd.Run()
	if err == nil {
		fmt.Println("Starting Oracle command succeeded")
		return true
	} else {
		fmt.Println("Error Starting Oracle", err)
		return false
	}
}

func powerOffOracle() bool {
	cmd := exec.Command("bash", "-c", "./stop_oracle.sh")
	err := cmd.Run()
	if err == nil {
		fmt.Println("Stopping Oracle command succeeded")
		return true
	} else {
		fmt.Println("Error Stopping Oracle", err)
		return false
	}
}

func powerOnOracleHandler(writer http.ResponseWriter, request *http.Request) {
	result := powerOnOracle()
	if result == true {
		time.Sleep(10 * time.Second)
		http.Redirect(writer, request, "/", 302)
	} else {
		// TODO: Ver como render el error
		http.Redirect(writer, request, "/", 302)
	}
}

func powerOffOracleHandler(writer http.ResponseWriter, request *http.Request) {
	result := powerOffOracle()
	if result == true {
		time.Sleep(10 * time.Second)
		http.Redirect(writer, request, "/", 302)
	} else {
		// TODO: Ver como render el error
		http.Redirect(writer, request, "/", 302)
	}
}

func main() {
	loadTemplates()

	http.HandleFunc("/", indexHandler)
	http.HandleFunc("/power-on-oracle", powerOnOracleHandler)
	http.HandleFunc("/power-off-oracle", powerOffOracleHandler)

	err := http.ListenAndServe(":5001", nil)
	if err != nil {
		fmt.Println(err)
	}
}