main.go

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"log"
	"math"
	"os"
	"runtime"
	"strconv"
	"strings"
	"time"

	//	"io/ioutil"
	"net/http"
)

type arraySpeciesJSON struct {
	ArryJson []speciesJSON2 `json:"results"`
}

type specisYearJson struct {

	Key float64  `json:"key"`
}


type countryJSON struct {
	Code 				string `json:"code"`
	Countryname 		string `json:"countryname"`
	CountryFlag 		string `json:"countryflag"`
	Species 			[]speciesJSON2 `json:"species"`
	SpeciesKey 			[]specisYearJson `json:"speciesKey"`

}

type speciesJSON2 struct {
	Key					float64 `json:"key"`
	Kingdom				string `json:"kingdom"`
	Phylum				string `json:"phylum"`
	Order				string `json:"order"`
	Family				string `json:"family"`
	Genus				string `json:"genus"`
	ScientificName		string `json:"scientificName"`
	CanonicalName		string `json:"canonicalName"`
	Year				float64 `json:"year"`
}

type speciesJSON struct {
	Key					float64 `json:"key"`
	Kingdom				string `json:"kingdom"`
	Phylum				string `json:"phylum"`
	Order				string `json:"order"`
	Family				string `json:"family"`
	Genus				string `json:"genus"`
	ScientificName		string `json:"scientificName"`
	CanonicalName		string `json:"canonicalName"`
	Year				string `json:"year"`
}

type diagJSON struct {
	Gbif 				int `json:"gbif"`
	Rescountries		int `json:"rescountries"`
	Version 			string `json:"version"`
	Uptime 				float64 `json:"uptime"`

}

var(
	StartTime = time.Time{}
	countryFilter 	= "/conservation/v1/country/"
	specisFilter 	= "/conservation/v1/species/"
	diagFilter 		= "/conservation/v1/diag/"
)


func main() {


	/*fiks limit
	finn ut om vi trenger å lage en json //ja, desverre
	lag riktig json for country/specis/diag
	inkluder år i species
	finn ut hvordan man finner diag informationen //ping something
	inkluder specis i country
	remove dupes


	//optional
	add error code handinling
	add custom 404
	add rate limiting
	startTime := time.Now()

	*/
	// add switch here

	StartTime = time.Now()

	http.HandleFunc("/", undefined)

	http.HandleFunc(countryFilter, country)
	http.HandleFunc(specisFilter, species)
	http.HandleFunc(diagFilter, diag)


	port := os.Getenv("PORT")

	if port == "" {
		port = "8080"
	}

	println(port)
	log.Fatal(http.ListenAndServe(":"+port, nil))


}

func undefined(w http.ResponseWriter, r *http.Request){


	io.WriteString(w, "please use /country,/species,/diag  ")
}


func country(w http.ResponseWriter, r *http.Request){

	//io.WriteString(w, "\ncountry\n\n")

	fmt.Fprint(w, "\nCountry\n\n")
	var input = r.URL.String()


	filtered := strings.Replace(input,countryFilter, "", -1)
	countryCode := string(filtered[0:2])

	filterNumber := strings.Replace(filtered,"?limit=", "", -1)
	filterNumber = filterNumber[:]

//	limit := filterNumber // TODO add number check here

	tempLimit := 10

	resp, err := http.Get("https://restcountries.eu/rest/v2/alpha/"+countryCode)
	if err != nil {
		print("error\n")
		log.Fatalln(err)

	}

	respSpecis, err := http.Get("http://api.gbif.org/v1/occurrence/search?country="+countryCode+"&"+"limit="+strconv.Itoa(tempLimit))
		if err != nil {
			print("error\n")
			log.Fatalln(err)

		}

//	defer respSpecis.Body.Close()
//	bodySpecis, err := ioutil.ReadAll(respSpecis.Body)

//	if err != nil {
//		print("error\n")
//		log.Fatalln(err)

//	}


//	var infoSpecis map[string]interface{}
//	json.Unmarshal([]byte(bodySpecis),&infoSpecis)



	//	numberResponce := infoSpecis["limit"]

	//	var intNumberResponce int = int(numberResponce.(float64))



//		var countryJsonArray []speciesJSON

	/*	var objmap map[string]*json.RawMessage
		//err = json.Unmarshal(bodySpecis, &objmap)


		var s interface{}

		err = json.Unmarshal(*objmap["results"], &s)

*/

		//err = json.Unmarshal(s[1], &test)


	//	str := fmt.Sprintf("%v", s)

	//	var test map[string]interface{}



	//	io.WriteString(w,string(str))

	//	str := fmt.Sprintf("%v", respSpecis.Body)

	//	println(str)
	var spectest arraySpeciesJSON


		err = json.NewDecoder(respSpecis.Body).Decode(&spectest)

		if err != nil {
			print("error\n")
			log.Fatalln(err)

		}

	var countryJsonArray []speciesJSON2
	var yearJsonArray []specisYearJson
	var duplicateCheck  = ""

	for i:=0; i<tempLimit ;i++ {

		keyTest := fmt.Sprintf("%f", spectest.ArryJson[i].Key)

		println(keyTest)

		if strings.Contains(duplicateCheck, keyTest) {
			continue
		}

			duplicateCheck += keyTest


			key            := spectest.ArryJson[i].Key
			kingdom        := spectest.ArryJson[i].Kingdom
			phylum         := spectest.ArryJson[i].Phylum
			order          := spectest.ArryJson[i].Order
			family         := spectest.ArryJson[i].Family
			genus          := spectest.ArryJson[i].Genus
			scientificName := spectest.ArryJson[i].ScientificName
			canonicalName  := spectest.ArryJson[i].CanonicalName
			year           := spectest.ArryJson[i].Year



			tempJson := speciesJSON2{float64(key),kingdom, phylum,order,family,
				genus,scientificName,canonicalName,year}

			tempYearJson := specisYearJson{key}

			countryJsonArray =append(countryJsonArray,tempJson)
			yearJsonArray =append(yearJsonArray,tempYearJson)


	}



	for index, element := range countryJsonArray{
		fmt.Println(index, "=>", element)
	}

	if err != nil {
		print("error\n")
		log.Fatalln(err)

	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {
		print("error\n")
		log.Fatalln(err)

	}

	var info map[string]interface{}
	json.Unmarshal([]byte(body),&info)

	//initalises temp variables and set their default values incase something goes wrong
	//todo make this work properly
/*	tempCode 		 := "error, unable to locate code"
	tempCountryname  := "error, unable to locate countryname"
	tempCountryFlag  := "error, unable to locate countryflag"
	tempSpecies 	 := "error, unable to locate specis"
	tempSpeciesKey 	 := "error, unable to locate specis key"
*/


	tempCode 		:= info["alpha2Code"]
	tempCountryname := info["name"]
	tempCountryFlag := info["flag"]
	//tempSpecies 	:= "work in progress " //todo
	//tempSpeciesKey 	:=  "work in progress " //todo


	//this is so i can collapse this test //todo fix species and key test
	{
		if tempCode == nil {
			tempCode = "NA"
		}
		if tempCountryname == nil {
			tempCountryname = "NA"
		}
		if tempCountryFlag == nil {
			tempCountryFlag = "NA"
		}

	}


	createdJson := countryJSON{tempCode.(string),tempCountryname.(string),tempCountryFlag.(string),
		countryJsonArray,yearJsonArray}



	e,err := json.Marshal(createdJson)


//	fmt.Fprint(w,(json.MarshalIndent(string(e), "", "    ")))

	io.WriteString(w,string(e))

}

func species(w http.ResponseWriter, r *http.Request){
	io.WriteString(w, "\nspecies\n\n")

	var input = r.URL.Path[:]
	filtred := strings.Replace(input,specisFilter, "", -1)

	resp,err := http.Get("http://api.gbif.org/v1/species/"+filtred)

	if err != nil {
		print("error\n")
		log.Fatalln(err)

	}

	defer resp.Body.Close()
	body, err := ioutil.ReadAll(resp.Body)

	if err != nil {
		print("error\n")
		log.Fatalln(err)
	}


	var info map[string]interface{}
	json.Unmarshal([]byte(body),&info)




	tempKey				:=info["key"]
	tempNameKey 		:=info["nameKey"]
	tempKingdom			:=info["kingdom"]
	tempPhylum			:=info["phylum"]
	tempOrder			:=info["order"]
	tempFamily			:=info["family"]
	tempGenus			:=info["genus"]
	tempScientificName	:=info["scientificName"]
	tempCanonicalName	:=info["canonicalName"]


	//this is so i can collapse this test //todo fix year test
	{
		if tempKey == nil  {
			tempKey = "NA"
		}
		if tempKingdom == nil  {
			tempKingdom = "NA"
		}
		if tempPhylum == nil  {
			tempPhylum = "NA"
		}
		if tempFamily == nil  {
			tempFamily = "NA"
		}
		if tempGenus == nil  {
			tempGenus = "NA"
		}
		if tempScientificName == nil  {
			tempScientificName = "NA"
		}

		if tempCanonicalName == nil  {
			tempCanonicalName = "NA"
		}



	}

	var namekeyInt int = int(tempNameKey.(float64))

	respYear,err := http.Get("http://api.gbif.org/v1/species/"+strconv.Itoa(namekeyInt)+"/name")

	if err != nil {
		print("error\n")
		log.Fatalln(err)

	}

	defer respYear.Body.Close()
	bodyYear, err := ioutil.ReadAll(respYear.Body)

	if err != nil {
		print("error\n")
		log.Fatalln(err)
	}

	var infoYear map[string]interface{}
	json.Unmarshal([]byte(bodyYear),&infoYear)

	tempYear :=infoYear["year"]
	fmt.Println(tempYear)

	//todo add year check


	createdJson := speciesJSON{tempKey.(float64),tempKingdom.(string), tempPhylum.(string), tempOrder.(string),tempFamily.(string),
		tempGenus.(string),tempScientificName.(string),tempCanonicalName.(string), tempYear.(string)}


	e,err := json.Marshal(createdJson)


	io.WriteString(w,string(e))
}



func diag(w http.ResponseWriter, r *http.Request){

	gbifCode := 0
	rescountriesCode := 0
	version := runtime.Version()
	serverRuntime := time.Since(StartTime).Seconds() //todo fix
	serverRuntime = math.Round(serverRuntime*100)/100

	respGbif,err := http.Get("http://api.gbif.org/")
	if err != nil{
		println(err.Error())
	}else{
		gbifCode = respGbif.StatusCode
	}

	respRestcountries,err := http.Get("http://restcountries.eu/")
	if err != nil{
		println(err.Error())
	}else{
		rescountriesCode = respRestcountries.StatusCode

	}

	createdJson := diagJSON{gbifCode,rescountriesCode,version,serverRuntime}


	e,err := json.Marshal(createdJson)


	io.WriteString(w,string(e))


}