package main

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

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

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

	index := mainTempl.Lookup("index.html")
	jobs := c.Entries()

	h := []Host{}
	for k, _ := range hosts {
		if !hosts[k].Private {
			h = append(h, hosts[k])
		}
	}
	sticky, _ := GetCache(cache_prefix + "sticky")
	m := Messages{Hosts: h, NextRun: jobs[0].Next, Sticky: sticky}

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

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 PrintNewJobHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Printing job")

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

	m := Messages{}
	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)
	}
	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 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("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 AdminHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get Admin")
	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
	}
	hosts := []Host{}
	Db.Find(&hosts)

	jobs := c.Entries()

	m := Messages{}
	m.Success = session.Flashes("success")
	m.Error = session.Flashes("error")
	m.Hosts = hosts
	m.NextRun = jobs[0].Next
	m.Sticky, _ = GetCache(cache_prefix + "sticky")
	session.Save(r, w)

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

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

func RefreshAllHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get RefreshAllHandler")
	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
	}
	go func() {
		h := []Host{}
		Db.Find(&h)
		h = CheckAllPages(h)
		CacheHosts(cache_prefix+"database", h)
		for k, _ := range h {
			Db.Debug().Save(&h[k])
		}
	}()
	session.AddFlash("Processing all hosts. This might take a while.", "success")
	session.Save(r, w)
	http.Redirect(w, r, "/admin", 302)
}

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()
}

func NewStickyHandler(w http.ResponseWriter, r *http.Request) {
	log.Println("Get NewStickyHandler")
	session, err := store.Get(r, "_SID")
	if err != nil {
		log.Println(err)
	}
	if session.Values["login"] != true {
		log.Println("Login required. File: New Sticky")
		session.AddFlash("Login required.", "error")
		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
	}
	sticky := Sticky{}
	err = decoder.Decode(&sticky, r.PostForm)
	if err != nil {
		log.Println(err)
		session.AddFlash("Error Parsing form.", "error")
		session.Save(r, w)
		http.Redirect(w, r, "/admin", 302)
		return
	}
	if r.PostFormValue("Action") == "delete" {
		log.Println("Deleting sticky post.")
		DelCache(cache_prefix + "sticky")
		session.AddFlash("Deleted the information post!", "success")
	} else {
		if sticky.Sticky == "" {
			session.AddFlash("Empty form. Please fill out some text.", "error")
			session.Save(r, w)
			http.Redirect(w, r, "/admin", 302)
			return
		}
		c := pool.Get()
		defer c.Close()

		_, err = c.Do("SET", cache_prefix+"sticky", sticky.Sticky)
		if err != nil {
			log.Println(err)
			session.AddFlash("Error while storing.", "error")
		} else {
			log.Println("Adding new sticky post.")
			session.AddFlash("Updated the information post.", "success")
		}
	}
	session.Save(r, w)
	http.Redirect(w, r, "/admin", 302)
}