package main

import (
	"AUDIAG/rtcusertr/database"
	"AUDIAG/rtcusertr/domain"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"strconv"

	"github.com/gorilla/mux"
	"github.com/sirupsen/logrus"
)

const MaxBT = 4
const MaxED = 186
const MinED = 100
const MaxEK = 85
const MaxGQ = 32
const MaxPG = 200

type Master struct {
}

func main() {

	fmt.Println("This is rtcusertrd!!!")
	logFile, err := os.OpenFile("rtcusertr.log", os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
	if err != nil {
		logrus.Fatal(err)
	}

	defer logFile.Close()

	logrus.SetOutput(logFile)
	logrus.SetLevel(logrus.InfoLevel)
	r := mux.NewRouter()

	r.HandleFunc("/api/kn", createKnotenEHandler).Methods("POST", "OPTIONS")
	r.HandleFunc("/api/kn/{id:[0-9]+}", deleteKnotenEHandler).Methods("DELETE", "OPTIONS")
	r.HandleFunc("/api/kn", showKnotenEHandler).Methods("GET", "OPTIONS")
	r.HandleFunc("/api/kn/{id:[0-9]+}", getKnotenEHandler).Methods("GET", "OPTIONS")
	r.HandleFunc("/api/kn/{id:[0-9]+}", updateKnotenEHandler).Methods("PUT", "OPTIONS")

	http.Handle("/", r)
	r.Use(mux.CORSMethodMiddleware(r))
	http.ListenAndServe(":8081", r)
	logrus.Info("running on localhost, Port 8081")

}

func createKnotenEHandler(writer http.ResponseWriter, req *http.Request) {
	writer.Header().Set("Access-Control-Allow-Origin", "*")
	if req.Method == http.MethodOptions {
		return
	}
	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		writer.WriteHeader(http.StatusBadRequest)
	}
	var knoten domain.KnotenE
	json.Unmarshal(body, &knoten)
	logrus.Println("Name= ", knoten.Fachbereich)
	logrus.Info("creating new Knoten-Eintrag", knoten.Fachbereich)
	res, err := database.CreateTool(knoten)
	if err != nil {
		writer.WriteHeader(http.StatusInternalServerError)
	}

	b, err := json.Marshal(res)
	if err != nil {
		logrus.Fatal("Error: ", err)
	}

	location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
	writer.Header().Set("Location:", location)
	writer.Header().Set("Content-Type", "application/json")
	writer.WriteHeader(http.StatusCreated)
	writer.Write(b)
}

func deleteToolsHandler(writer http.ResponseWriter, req *http.Request) {
	writer.Header().Set("Access-Control-Allow-Origin", "*")
	if req.Method == http.MethodOptions {
		return
	}
	toolsId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
	log.Info("Deleting tool with ID", toolsId)
	_, err := database.DeleteTool(uint(toolsId))
	if err != nil {
		log.Fatal("Error: Delete could not be executed", err)
	}
	writer.WriteHeader(http.StatusNoContent)
}

func showToolsHandler(writer http.ResponseWriter, req *http.Request) {
	writer.Header().Set("Access-Control-Allow-Origin", "*")
	if req.Method == http.MethodOptions {
		return
	}
	res, err := database.ShowTool()
	if err != nil {
		log.Fatal("Error: Tool can't be shown ", err)
		writer.WriteHeader(http.StatusInternalServerError)
	}

	b, err := json.Marshal(res)
	if err != nil {
		log.Fatal("Error: ", err)
	}

	location := req.URL.String()
	writer.Header().Set("Location:", location)
	writer.Header().Set("Content-Type", "application/json")
	writer.WriteHeader(http.StatusOK)
	writer.Write(b)
}

func getToolsHandler(writer http.ResponseWriter, req *http.Request) {
	writer.Header().Set("Access-Control-Allow-Origin", "*")
	if req.Method == http.MethodOptions {
		return
	}
	toolId, _ := strconv.ParseUint(mux.Vars(req)["id"], 10, 0)
	res, err := database.GetTool(uint(toolId))
	if err != nil {
		log.Fatal("Error: Tool can't be shown ", err)
		writer.WriteHeader(http.StatusInternalServerError)
	}

	b, err := json.Marshal(res)
	if err != nil {
		log.Fatal("Error: ", err)
	}

	location := req.URL.String()
	writer.Header().Set("Location:", location)
	writer.Header().Set("Content-Type", "application/json")
	writer.WriteHeader(http.StatusOK)
	writer.Write(b)
}

func updateToolsHandler(writer http.ResponseWriter, req *http.Request) {
	writer.Header().Set("Access-Control-Allow-Origin", "*")
	if req.Method == http.MethodOptions {
		return
	}
	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		writer.WriteHeader(http.StatusBadRequest)
	}
	var tool domain.Tools
	json.Unmarshal(body, &tool)
	log.Println("Name = ", tool.Name)
	log.Info("updating Tool", tool.Name)
	res, err := database.UpdateTool(tool)
	if err != nil {
		writer.WriteHeader(http.StatusInternalServerError)
	}

	b, err := json.Marshal(res)
	if err != nil {
		log.Fatal("Error: ", err)
	}

	location := fmt.Sprintf("%s/%d", req.URL.String(), res.Id)
	writer.Header().Set("Location:", location)
	writer.Header().Set("Content-Type", "application/json")
	writer.WriteHeader(http.StatusOK)
	writer.Write(b)
}