package web

import (
	"adammathes.com/neko/config"
	"adammathes.com/neko/crawler"
	"adammathes.com/neko/models/feed"
	"adammathes.com/neko/models/item"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"golang.org/x/crypto/bcrypt"
	"io/ioutil"
	"log"
	"net/http"
	"path"
	"strconv"
	"time"
)

func indexHandler(w http.ResponseWriter, r *http.Request) {
	http.ServeFile(w, r, staticFilePath("ui.html"))
}

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

	max_id := 0
	if r.FormValue("max_id") != "" {
		max_id, _ = strconv.Atoi(r.FormValue("max_id"))
	}

	feed_id := int64(0)
	if r.FormValue("feed_url") != "" {
		feed_url := r.FormValue("feed_url")
		var f feed.Feed
		f.ByUrl(feed_url)
		feed_id = f.Id
	}

	category := ""
	if r.FormValue("tag") != "" {
		category = r.FormValue("tag")
	}

	unread_only := true
	if r.FormValue("read_filter") != "" {
		unread_only = false
	}

	starred_only := false
	if r.FormValue("starred") != "" {
		starred_only = true
	}

	var items []*item.Item
	items, err := item.Filter(int64(max_id), feed_id, category, unread_only, starred_only, 0)
	if err != nil {
		log.Println(err)
	}

	w.Header().Set("Content-Type", "application/json")
	js, _ := json.Marshal(items)
	w.Write(js)
}

func itemHandler(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case "PUT":
		var i item.Item
		err := json.NewDecoder(r.Body).Decode(&i)
		if err != nil {
			log.Println(err)
		} else {
			i.Save()
		}
	case "GET":
		fullTextHandler(w, r)
	}
	defer r.Body.Close()
}

func feedHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method == "GET" {
		feeds, err := feed.All()
		if err != nil {
			log.Println(err)
		}

		js, err := json.Marshal(feeds)
		if err != nil {
			log.Println(err)
		}
		w.Write(js)
		return
	}

	var f feed.Feed
	err := json.NewDecoder(r.Body).Decode(&f)
	if err != nil {
		log.Println(err)
	}

	switch r.Method {
	case "POST":
		feed.NewFeed(f.Url)
		f.ByUrl(f.Url)
		ch := make(chan string)
		// log.Println("crawling")
		crawler.CrawlFeed(&f, ch)
		log.Println(<-ch)
	case "PUT":
		f.Update()
	case "DELETE":
		feed_id, err := strconv.Atoi(r.URL.Path[len("/feed/"):])
		if err != nil {
			log.Println(err)
			return
		}
		f.Id = int64(feed_id)
		f.Delete()
	}
}

func categoryHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method == "GET" {
		categories, err := feed.Categories()
		if err != nil {
			log.Println(err)
		}

		js, err := json.Marshal(categories)
		if err != nil {
			log.Println(err)
		}
		w.Write(js)
		return
	}
}

func imageProxyHandler(w http.ResponseWriter, r *http.Request) {
	imgURL := r.URL.String()
	decodedURL, err := base64.URLEncoding.DecodeString(imgURL)

	// pseudo-caching
	if r.Header.Get("If-None-Match") == string(decodedURL) {
		w.WriteHeader(http.StatusNotModified)
		return
	}

	if r.Header.Get("Etag") == string(decodedURL) {
		w.WriteHeader(http.StatusNotModified)
		return
	}

	// set headers

	// grab the img
	c := &http.Client{
		// give up after 5 seconds
		Timeout: 5 * time.Second,
	}

	request, err := http.NewRequest("GET", string(decodedURL), nil)
	if err != nil {
		http.Error(w, "failed to proxy image", 404)
		return
	}

	userAgent := "neko RSS Reader Image Proxy +https://github.com/adammathes/neko"
	request.Header.Set("User-Agent", userAgent)
	resp, err := c.Do(request)

	if err != nil {
		http.Error(w, "failed to proxy image", 404)
		return
	}

	bts, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		http.Error(w, "failed to read proxy image", 404)
		return
	}

	w.Header().Set("ETag", string(decodedURL))
	w.Header().Set("Cache-Control", "public")
	w.Header().Set("Expires", time.Now().Add(48*time.Hour).Format(time.RFC1123))
	w.Write(bts)
	return
}

func fullTextHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Printf("request: %v\n\n", r)

	fmt.Printf("url string: %s\n\n", r.URL.String())

	itemID, _ := strconv.Atoi(r.URL.String())
	//	fmt.Printf("item id: %v\n\n", itemID)

	if itemID == 0 {
		fmt.Printf("wah wah wah\n")
		return
	}

	i := item.ItemById(int64(itemID))
	// fmt.Println("item fetched: %v\n\n", i)

	if i.FullContent == "" {
		i.GetFullContent()
	}

	w.Header().Set("Content-Type", "application/json")
	js, _ := json.Marshal(i)
	w.Write(js)
}

var AuthCookie = "auth"
var SecondsInAYear = 60 * 60 * 24 * 365

func loginHandler(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case "GET":
		http.ServeFile(w, r, staticFilePath("login.html"))
	case "POST":
		password := r.FormValue("password")
		if password == config.Config.DigestPassword {
			v, _ := bcrypt.GenerateFromPassword([]byte(password), 0)
			c := http.Cookie{Name: AuthCookie, Value: string(v), Path: "/", MaxAge: SecondsInAYear, HttpOnly: false}
			http.SetCookie(w, &c)
			http.Redirect(w, r, "/", 307)
		} else {
			http.Error(w, "bad login", 401)
		}
	default:
		http.Error(w, "nope", 500)
	}
}

func logoutHandler(w http.ResponseWriter, r *http.Request) {
	c := http.Cookie{Name: AuthCookie, MaxAge: 0, Path: "/", HttpOnly: false}
	http.SetCookie(w, &c)
	fmt.Fprintf(w, "you are logged out")
}

func Authenticated(r *http.Request) bool {
	pc, err := r.Cookie("auth")
	if err != nil {
		return false
	}
	err = bcrypt.CompareHashAndPassword([]byte(pc.Value), []byte(config.Config.DigestPassword))
	if err == nil {
		return true
	}
	return false
}

func AuthWrap(wrapped http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if Authenticated(r) {
			wrapped(w, r)
		} else {
			http.Redirect(w, r, "/login/", 307)
		}
	}
}

func Serve() {
	fs := http.FileServer(http.Dir(config.Config.StaticDir))
	http.Handle("/static/", http.StripPrefix("/static/", fs))

	http.HandleFunc("/stream/", AuthWrap(streamHandler))

	//	http.HandleFunc("/item/", AuthWrap(itemHandler))
	http.Handle("/item/", http.StripPrefix("/item/", AuthWrap(itemHandler)))

	http.HandleFunc("/feed/", AuthWrap(feedHandler))
	http.HandleFunc("/tag/", AuthWrap(categoryHandler))
	http.Handle("/image/", http.StripPrefix("/image/", AuthWrap(imageProxyHandler)))

	http.HandleFunc("/login/", loginHandler)
	http.HandleFunc("/logout/", logoutHandler)

	http.HandleFunc("/", AuthWrap(indexHandler))

	http.ListenAndServe(config.Config.WebServer, nil)
}

// given a path, prepend config.Config.StaticDir
// TODO: compile these into the binary to remove dependency on the files
func staticFilePath(p string) string {
	return path.Join(config.Config.StaticDir, p)
}