package main

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

func SetupHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get Setup")
	u := User{}
	if Db.Find(&u).RecordNotFound() {
		PrintRegisterHandler(w, r)
	} else {
		http.Redirect(w, r, "/login", 302)
	}
}

func RegisterHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Processing registration!")
	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)
	}
	u.Password, _ = HashPassword(u.Password)
	query := Db.Create(&u)
	if query.Error != nil {
		session.AddFlash("Registration failed.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/register", 302)
		return
	}
	session.AddFlash("Registration completed!", "success")
	session.Values["login"] = true
	session.Save(r, w)
	http.Redirect(w, r, "/admin", 302)
}

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

	err = templ.ExecuteTemplate(w, "register.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)
	}
	if session.Values["login"] != true {
		session.Values["history"] = "/new"
		session.Save(r, w)
		http.Redirect(w, r, "/login", 302)
		return
	}

	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" {
		session.AddFlash("Unsurportted scheme. Only http:// and https:// is valid.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
		return
	}

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

	query := Db.Save(&host)
	if query.Error != nil {
		log.Println(err)
		//session.AddFlash("Befehl konnte auf Grund eines Problems nicht ausgeführt werden.", "error")
		session.AddFlash("There was an error. :(", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
	}

	go func() {
		h := []Host{}
		Db.Find(&h)
		h = CheckPages(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 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("Processing Login", u.Name)
	login := login(u.Name, u.Password, session)
	if !login {
		session.AddFlash("Login failed.", "error")
		session.Save(r, w)
		log.Println("Login failed.")
		http.Redirect(w, r, "/login", 302)
		return
	}
	session.Values["login"] = true
	session.Save(r, w)
	var redirectTarget string
	if session.Values["history"] != "" && session.Values["history"] != nil {
		redirectTarget = fmt.Sprintf("%v", session.Values["history"])
		session.Values["history"] = ""
		session.Save(r, w)
		http.Redirect(w, r, redirectTarget, 301)
	}
	http.Redirect(w, r, "/admin", 301)
}

func PrintLoginHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get Login")
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}

	m := Messages{}
	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) {
	log.Println("Logout")
	session, _ := store.Get(r, "_SID")
	session.Values["login"] = false
	session.Save(r, w)
	http.Redirect(w, r, "/login", 301)
}

func DeleteHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get Delete")
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}
	if session.Values["login"] != true {
		session.Values["history"] = "/admin"
		session.Save(r, w)
		http.Redirect(w, r, "/login", 302)
		return
	}
	err = r.ParseForm()
	if err != nil {
		log.Println(err)
		session.AddFlash("Error parsing form.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
		return
	}
	host := Host{}
	err = decoder.Decode(&host, r.URL.Query())
	if err != nil {
		log.Println(err)
		session.AddFlash("Error parsing form.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
		return
	}
	log.Println("Deleting host where id = ", host.Id)
	query := Db.Where("id = ?", host.Id).Delete(&host)
	if query.Error != nil {
		session.AddFlash("Deleting failed.", "error")
		log.Println("Deleting failed.", query.Error)
	} else {
		session.AddFlash("We removed the host.", "success")
	}
	session.Save(r, w)
	http.Redirect(w, r, "/admin", 302)
	go FillCache()
}