package main

import "fmt"
import "log"
import "bytes"
import "net/http"
import "runtime/debug"

//var notfound_count_per_second int
//var noperms_count_per_second int

var error_internal []byte
var error_notfound []byte
func init_errors() error {
	var b bytes.Buffer
	user := User{0,"guest","Guest","",0,false,false,false,false,false,false,GuestPerms,nil,"",false,"","","","","",0,0,"0.0.0.0.0"}
	pi := Page{"Internal Server Error",user,hvars,tList,"A problem has occurred in the system."}
	err := templates.ExecuteTemplate(&b,"error.html", pi)
	if err != nil {
		return err
	}
	error_internal = b.Bytes()

	b.Reset()
	pi = Page{"Not Found",user,hvars,tList,"The requested page doesn't exist."}
	err = templates.ExecuteTemplate(&b,"error.html", pi)
	if err != nil {
		return err
	}
	error_notfound = b.Bytes()
	return nil
}

func LogError(err error) {
	log.Print(err)
	debug.PrintStack()
	log.Fatal("")
}

func InternalError(err error, w http.ResponseWriter) {
	w.Write(error_internal)
	log.Print(err)
	debug.PrintStack()
	log.Fatal("")
}

func InternalErrorJSQ(err error, w http.ResponseWriter, r *http.Request, is_js string) {
	w.WriteHeader(500)
	if is_js == "0" {
		w.Write(error_internal)
	} else {
		w.Write([]byte(`{"errmsg":"A problem has occured in the system."}`))
	}
	log.Print(err)
	debug.PrintStack()
	log.Fatal("")
}

func InternalErrorJS(err error, w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(500)
	w.Write([]byte(`{"errmsg":"A problem has occured in the system."}`))
	log.Fatal(err)
}

func PreError(errmsg string, w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(500)
	user := User{ID:0,Group:6,Perms:GuestPerms,}
	pi := Page{"Error",user,hvars,tList,errmsg}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html",pi)
	fmt.Fprintln(w,b.String())
}

func LocalError(errmsg string, w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(500)
	pi := Page{"Local Error",user,hvars,tList,errmsg}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html",pi)
	fmt.Fprintln(w,b.String())
}

func LoginRequired(w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(401)
	pi := Page{"Local Error",user,hvars,tList,"You need to login to do that."}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html",pi)
	fmt.Fprintln(w,b.String())
}

func PreErrorJSQ(errmsg string, w http.ResponseWriter, r *http.Request, is_js string) {
	w.WriteHeader(500)
	if is_js == "0" {
		user := User{ID:0,Group:6,Perms:GuestPerms,}
		pi := Page{"Local Error",user,hvars,tList,errmsg}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"` + errmsg + `"}`))
	}
}

func LocalErrorJSQ(errmsg string, w http.ResponseWriter, r *http.Request, user User, is_js string) {
	w.WriteHeader(500)
	if is_js == "0" {
		pi := Page{"Local Error",user,hvars,tList,errmsg}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"` + errmsg + `"}`))
	}
}

func LocalErrorJS(errmsg string, w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(500)
	w.Write([]byte(`{'errmsg': '` + errmsg + `'}`))
}

func NoPermissions(w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(403)
	pi := Page{"Local Error",user,hvars,tList,"You don't have permission to do that."}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html", pi)
	errpage := b.String()
	fmt.Fprintln(w,errpage)
}

func NoPermissionsJSQ(w http.ResponseWriter, r *http.Request, user User, is_js string) {
	w.WriteHeader(403)
	if is_js == "0" {
		pi := Page{"Local Error",user,hvars,tList,"You don't have permission to do that."}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"You don't have permission to do that."}`))
	}
}

func Banned(w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(403)
	pi := Page{"Banned",user,hvars,tList,"You have been banned from this site."}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html", pi)
	fmt.Fprintln(w,b.String())
}

func BannedJSQ(w http.ResponseWriter, r *http.Request, user User, is_js string) {
	w.WriteHeader(403)
	if is_js == "0" {
		pi := Page{"Banned",user,hvars,tList,"You have been banned from this site."}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"You have been banned from this site."}`))
	}
}

func LoginRequiredJSQ(w http.ResponseWriter, r *http.Request, user User, is_js string) {
	w.WriteHeader(401)
	if is_js == "0" {
		pi := Page{"Local Error",user,hvars,tList,"You need to login to do that."}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"You need to login to do that."}`))
	}
}

func SecurityError(w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(403)
	pi := Page{"Security Error",user,hvars,tList,"There was a security issue with your request."}
	if pre_render_hooks["pre_render_security_error"] != nil {
		if run_pre_render_hook("pre_render_security_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html", pi)
	fmt.Fprintln(w,b.String())
}

func NotFound(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(404)
	w.Write(error_notfound)
}

func CustomError(errmsg string, errcode int, errtitle string, w http.ResponseWriter, r *http.Request, user User) {
	w.WriteHeader(errcode)
	pi := Page{errtitle,user,hvars,tList,errmsg}
	if pre_render_hooks["pre_render_error"] != nil {
		if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
			return
		}
	}
	var b bytes.Buffer
	templates.ExecuteTemplate(&b,"error.html", pi)
	fmt.Fprintln(w,b.String())
}

func CustomErrorJSQ(errmsg string, errcode int, errtitle string, w http.ResponseWriter, r *http.Request, user User, is_js string) {
	w.WriteHeader(errcode)
	if is_js == "0" {
		pi := Page{errtitle,user,hvars,tList,errmsg}
		if pre_render_hooks["pre_render_error"] != nil {
			if run_pre_render_hook("pre_render_error", w, r, &user, &pi) {
				return
			}
		}
		var b bytes.Buffer
		templates.ExecuteTemplate(&b,"error.html", pi)
		fmt.Fprintln(w,b.String())
	} else {
		w.Write([]byte(`{"errmsg":"` + errmsg + `"}`))
	}
}