package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"net/url"
)

func IndexHandler(w http.ResponseWriter, r *http.Request) {
	hosts := []Host{}

	c := pool.Get()
	defer c.Close()

	j, err := GetCache(cache_prefix + "database")
	if j != "" {
		err = json.Unmarshal([]byte(j), &hosts)
		if err != nil {
			log.Println("Error JSON decoding: ", err)
			Db.Find(&hosts)
			CacheHosts(cache_prefix+"database", hosts)
		}
	} else {
		log.Println("Cache miss on Index page.")
		Db.Find(&hosts)
		CacheHosts(cache_prefix+"database", hosts)
	}

	index := mainTempl.Lookup("index.html")

	err = index.ExecuteTemplate(w, "index.html", hosts)
	if err != nil {
		log.Println(err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func SessionHandler(w http.ResponseWriter, r *http.Request) {
	session, _ := store.Get(r, "session-name")
	session.Values["foo"] = "bar"
	session.Values[42] = 43
	session.Save(r, w)
}

func RegisterHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Processing registration!")
	fmt.Fprintf(w, "Processing registration! \n")
}

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

	fmt.Fprintf(w, "Printing register etc! \n")
}

func PrintNewJobHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Printing job")

	session, err := store.Get(r, "_SID")

	m := FlashMessages{}
	m.Success = session.Flashes("success")
	m.Error = session.Flashes("error")
	session.Save(r, w)

	job := mainTempl.Lookup("jobs.html")

	err = job.ExecuteTemplate(w, "jobs.html", m)
	if err != nil {
		log.Panic(err)
	}
}

func AddNewJobHandler(w http.ResponseWriter, r *http.Request) {
	log.Printf("Add new job")
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}

	err = r.ParseForm()
	if err != nil {
		log.Panic(err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	host := Host{}
	err = decoder.Decode(&host, r.PostForm)
	if err != nil {
		log.Println(err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	u, err := url.Parse(host.Url)
	if err != nil {
		log.Println(err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if u.Scheme != "http" && u.Scheme != "https" {
		log.Println("Scheme neither http nor https.", u.Scheme)
		session.AddFlash("Unsurportted scheme. Only http:// and https:// is valid.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
		//	http.Error(w, "Scheme neither http nor https.", http.StatusInternalServerError)
		return
	}

	host.Monitored = true
	host.Host = u.Host

	log.Printf("%v", host)
	Db.Debug().Save(&host)

	go func() {
		h := []Host{}
		h = append(h, host)
		h = CheckPage(h)
		for k, _ := range h {
			Db.Debug().Save(&h[k])
		}
		CacheHosts(cache_prefix+"database", h)
	}()

	session.AddFlash("Job added!", "success")
	session.Save(r, w)

	http.Redirect(w, r, "/admin", 302)

}

func ShowJobHandler(w http.ResponseWriter, r *http.Request) {
	jobs := c.Entries()

	for _, i := range jobs {
		fmt.Fprintf(w, "Job: %v, Schedule: %v; Next %v; Prev %v \n", i.Job, i.Schedule, i.Next, i.Prev)
	}
}

func LoginHandler(w http.ResponseWriter, r *http.Request) {
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}
	u := User{}
	err = r.ParseForm()
	if err != nil {
		log.Println(err)
	}
	err = decoder.Decode(&u, r.PostForm)
	if err != nil {
		log.Println(err)
	}
	log.Println(u)
	login := login(u.Name, u.Password, session)
	if !login {
		session.AddFlash("Login failed.", "error")
		session.Save(r, w)
		log.Println("Login failed.")
		log.Println(u.Name, u.Password)
		http.Redirect(w, r, "/login", 302)
		return
	}
	session.Values["login"] = true
	session.Save(r, w)
	http.Redirect(w, r, "/admin", 301)
}

func PrintLoginHandler(w http.ResponseWriter, r *http.Request) {
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}
	if session.Values["login"] == true {
		log.Println("Schon erfolgreich eingeloggt!")
		//	http.Redirect(w, r, "/", 301)
	} else {
		log.Println("Nicht eingeloggt.")
	}
	m := FlashMessages{}
	m.Success = session.Flashes("success")
	m.Error = session.Flashes("error")
	session.Save(r, w)
	templ := mainTempl.Lookup("login.html")

	err = templ.ExecuteTemplate(w, "login.html", m)
	if err != nil {
		log.Panic(err)
	}
}

func LogoutHandler(w http.ResponseWriter, r *http.Request) {
	session, _ := store.Get(r, "_SID")
	session.Values["login"] = false
	session.Save(r, w)
	http.Redirect(w, r, "/", 301)
}

func AdminHandler(w http.ResponseWriter, r *http.Request) {
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}
	if session.Values["login"] != true {
		//		http.Redirect(w, r, "/login", 401)
		PrintLoginHandler(w, r)
		return
	}
	hosts := []Host{}
	Db.Find(&hosts)

	a := Admin{}
	a.Success = session.Flashes("success")
	a.Error = session.Flashes("error")
	a.Hosts = hosts
	session.Save(r, w)

	index := mainTempl.Lookup("admin.html")

	err = index.ExecuteTemplate(w, "admin.html", a)
	if err != nil {
		log.Println(err)
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}