package main

import (
	"compress/gzip"
	"encoding/json"
	"fmt"
	"github.com/gorilla/mux"
	"io"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path/filepath"
	"pvs_tsp/tspreader"
	"strings"
)

func main() {
	startServer(8000)
}

func startServer(port int)  {

	r := mux.NewRouter()

	r.HandleFunc("/readtsp", postTsp).Methods("POST")
	r.HandleFunc("/upload", getUpload).Methods("GET")

	http.ListenAndServe(fmt.Sprintf(":%d",port), r)
	log.Printf("server running on http://localhost:%d", port)
}

func getUpload(w http.ResponseWriter, r *http.Request)  {
	http.ServeFile(w, r, "./index.html")
}

func postTsp(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	// get file from Request
	file, handler, err := r.FormFile("tspspec")
	if err != nil {
		fmt.Println("Error reading file")
		fmt.Println(err)
		return
	}
	defer file.Close()

	filepath := fmt.Sprintf("./data/web/%s", handler.Filename)

	// Write File
	f, err := os.Create(filepath)
	fileBytes, err := ioutil.ReadAll(file)
	if err != nil {
		fmt.Println(err)
	}
	defer f.Close()
	f.Write(fileBytes)

	spec := readtsp(filepath)

	// Response
	w.WriteHeader(http.StatusOK)
	json.NewEncoder(w).Encode(spec.String())
}

func readtsp(path string) *tspreader.TspSpec {

	if strings.HasSuffix(path,".gz") {
		_ = UnGzip(path, filepath.Dir(path))
	}

	spec, e := tspreader.Read(strings.TrimSuffix(path,".gz"))
	if e != nil {
		log.Fatal(e.Error())
	}

	return spec
}


func UnGzip(source, target string) error {
	reader, err := os.Open(source)
	if err != nil {
		return err
	}
	defer reader.Close()

	archive, err := gzip.NewReader(reader)
	if err != nil {
		return err
	}
	defer archive.Close()

	target = filepath.Join(target, archive.Name)
	writer, err := os.Create(target)
	if err != nil {
		return err
	}
	defer writer.Close()

	_, err = io.Copy(writer, archive)
	return err
}