package caddyhugo

import (
	"encoding/base64"
	"errors"
	"fmt"
	"html/template"
	"io/ioutil"
	"net/http"
	_ "net/http/pprof"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"strings"
	"sync"
	"time"

	"git.stephensearles.com/stephen/acedoc"
	"git.stephensearles.com/stephen/caddy-hugo2/assets"

	"github.com/gorilla/websocket"
	"github.com/mholt/caddy"
	"github.com/mholt/caddy/caddyhttp/httpserver"
	"github.com/spf13/afero"
	"github.com/spf13/hugo/deps"
	"github.com/spf13/hugo/hugofs"
	"github.com/spf13/hugo/hugolib"
)

const (
	IdleWebsocketTimeout = 10 * time.Minute
	WebsocketFileTicker  = 1 * time.Second
)

func init() {
	plugin := CaddyHugo{}

	// register a "generic" plugin, like a directive or middleware
	caddy.RegisterPlugin("hugo", caddy.Plugin{
		ServerType: "http",
		Action:     plugin.Setup,
	})

	// ... there are others. See the godoc.
}

type docref struct {
	clients uint
	name    string
	doc     *acedoc.Document
	tmpdir  string
}

type CaddyHugo struct {
	ServerType string
	Site       *httpserver.SiteConfig
	HugoSites  *hugolib.HugoSites
	HugoCfg    *deps.DepsCfg

	Media *MediaSource

	docs map[string]*docref
	mtx  sync.Mutex

	authorTmpl, adminTmpl, editTmpl *template.Template

	ltime uint64
}

func (ch *CaddyHugo) ObserveLTime(ltime uint64) uint64 {
	ch.mtx.Lock()

	if ch.ltime < ltime {
		ch.ltime = ltime
	}

	ch.mtx.Unlock()
	return ch.LTime()
}

func (ch *CaddyHugo) LTime() uint64 {
	ch.mtx.Lock()
	defer ch.mtx.Unlock()
	ch.ltime++
	return ch.ltime
}

func (ch *CaddyHugo) Build() error {
	err := ch.HugoSites.Build(hugolib.BuildCfg{ResetState: true})
	if err != nil {
		return fmt.Errorf("error building hugo sites: %v", err)
	}

	return nil
}

func (ch *CaddyHugo) Setup(c *caddy.Controller) error {
	var err error

	ch.docs = make(map[string]*docref)
	ch.Site = httpserver.GetConfig(c)

	ch.HugoCfg = &deps.DepsCfg{}

	ch.HugoCfg.Cfg, err = hugolib.LoadConfig(hugofs.Os, ch.Site.Root, "")
	if err != nil {
		return fmt.Errorf("error loading hugo config: %v", err)
	}

	ch.HugoCfg.Cfg.Set("workingdir", ch.Site.Root)
	ch.HugoSites, err = hugolib.NewHugoSites(*ch.HugoCfg)
	if err != nil {
		return fmt.Errorf("error intializing hugo: %v", err)
	}

	err = ch.Build()
	if err != nil {
		return fmt.Errorf("error building initial hugo: %v", err)
	}

	ch.authorTmpl, err = template.New("").Parse(AuthorPage)
	if err != nil {
		return fmt.Errorf("author template invalid: %v", err)
	}

	ch.adminTmpl, err = template.New("").Parse(AdminPage)
	if err != nil {
		return fmt.Errorf("admin template invalid: %v", err)
	}

	ch.editTmpl, err = template.New("").Parse(EditPage)
	if err != nil {
		return fmt.Errorf("edit template invalid: %v", err)
	}

	thumbDir, err := ioutil.TempDir("", "thumbs")
	if err != nil {
		return fmt.Errorf("couldn't initialize media: %v", err)
	}

	ch.Media = &MediaSource{
		StorageDir: path.Join(ch.Site.Root, "media"),
		ThumbDir:   thumbDir,
	}

	err = os.MkdirAll(ch.Media.StorageDir, 0755)
	if err != nil {
		return fmt.Errorf("couldn't initialize media: %v", err)
	}

	// add a function that wraps listeners for the HTTP server
	// (it's more common for a directive to call this rather than a standalone plugin)
	ch.Site.AddMiddleware(ch.Middleware(c))

	return ch.Publish()
}

func (ch *CaddyHugo) ServeHTTPWithNext(next httpserver.Handler, c *caddy.Controller, w http.ResponseWriter, r *http.Request) (int, error) {
	if !ch.Match(r) {
		p := path.Join(ch.Site.Root, "public", r.URL.Path)
		http.ServeFile(w, r, p)
		return 200, nil
	}

	if !ch.Auth(r) {
		return http.StatusUnauthorized, errors.New("not authorized")
	}

	if strings.HasPrefix(r.URL.Path, "/hugo/publish") {
		err := ch.Publish()
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return http.StatusInternalServerError, nil
		}

		http.Redirect(w, r, "/", http.StatusFound)
		return http.StatusFound, nil
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.css") {
		w.Write(assets.MustAsset("simplemde/dist/simplemde.min.css"))
		return http.StatusOK, nil
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/simplemde.js") {
		w.Write(assets.MustAsset("simplemde/debug/simplemde.js"))
		return http.StatusOK, nil
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/admin") {
		return ch.Admin().ServeHTTP(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/author") {
		return ch.AuthorHome().ServeHTTP(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/edit/") {
		return ch.Edit(c).ServeHTTP(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/draft/") {
		return ch.serveDraft(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/media") {
		return ch.serveMediaPage(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/hugo/upload") {
		return ch.uploadMedia(w, r)
	}
	if strings.HasPrefix(r.URL.Path, "/media/") {
		return ch.serveMedia(w, r)
	}

	http.NotFound(w, r)
	return 404, nil
}

func (ch CaddyHugo) Middleware(c *caddy.Controller) httpserver.Middleware {
	return func(next httpserver.Handler) httpserver.Handler {
		return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
			return ch.ServeHTTPWithNext(next, c, w, r)
		})
	}
}

func (ch CaddyHugo) Auth(r *http.Request) bool {
	return true
}

func (ch CaddyHugo) Match(r *http.Request) bool {
	if strings.HasPrefix(r.URL.Path, "/media/") {
		return true
	}

	if r.URL.Path == "/hugo" {
		return true
	}

	return strings.HasPrefix(r.URL.Path, "/hugo/")
}

func (ch CaddyHugo) BasePath() string {
	return "/hugo"
}

func (ch CaddyHugo) Admin() httpserver.Handler {
	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
		err := ch.adminTmpl.Execute(w, ch.TmplData(r, nil))
		if err != nil {
			fmt.Println(err)
			return http.StatusInternalServerError, err
		}

		return http.StatusOK, nil

	})
}

func (ch CaddyHugo) AuthorHome() httpserver.Handler {
	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
		td := ch.TmplData(r, nil)
		err := ch.authorTmpl.Execute(w, td)
		if err != nil {
			fmt.Println(err)
			return http.StatusInternalServerError, err
		}

		return http.StatusOK, nil
	})
}

func (ch *CaddyHugo) Edit(c *caddy.Controller) httpserver.Handler {
	return httpserver.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
		if r.URL.Path == "/hugo/edit/new" {
			return ch.NewContent(w, r)
		}

		if r.Header.Get("Upgrade") == "websocket" {
			return ch.DeltaWebsocket(w, r)
		}

		doc, err := ch.doc(r)
		if err != nil {
			fmt.Println(err)
			return http.StatusNotFound, err
		}

		err = ch.editTmpl.Execute(w, ch.TmplData(r, doc))
		if err != nil {

			fmt.Println(err)
			return http.StatusInternalServerError, err
		}

		return http.StatusOK, nil
	})
}

func (ch *CaddyHugo) serveDraft(w http.ResponseWriter, r *http.Request) (int, error) {
	pathSegments := strings.SplitN(r.URL.Path, "/", 5)
	if len(pathSegments) < 4 {

		return http.StatusNotFound, nil
	}

	encoded := pathSegments[3]

	nameBytes, err := base64.RawURLEncoding.DecodeString(encoded)
	if err != nil {
		return http.StatusNotFound, err
	}

	name := string(nameBytes)

	ch.mtx.Lock()
	defer ch.mtx.Unlock()

	docref, ok := ch.docs[name]
	if !ok {
		return http.StatusNotFound, fmt.Errorf("draft not found")
	}

	http.StripPrefix(
		"/hugo/draft/"+encoded,
		http.FileServer(http.Dir(docref.tmpdir))).ServeHTTP(w, r)
	return 200, nil
}

func (ch *CaddyHugo) doc(r *http.Request) (*docref, error) {
	ch.mtx.Lock()
	defer ch.mtx.Unlock()

	name := r.URL.Path[len("/hugo/edit/"):]
	name = filepath.Join(ch.Site.Root, name)

	_, ok := ch.docs[name]
	if !ok {
		fmt.Println("opening", name)
		contents, err := ioutil.ReadFile(name)
		if err != nil {
			return nil, err
		}

		draftPrefix := fmt.Sprintf("draft-%s", base64.RawURLEncoding.EncodeToString([]byte(name)))
		tmpdir := path.Join(os.TempDir(), draftPrefix)

		ref := &docref{
			name:   name,
			doc:    acedoc.NewString(string(contents)),
			tmpdir: tmpdir,
		}

		err = ref.doc.LogToFile(path.Join(ch.Site.Root, "logs", r.URL.Path[len("/hugo/edit/"):]))
		if err != nil {
			fmt.Println(err)
			return nil, err
		}

		ch.docs[name] = ref

		hugoCmd := exec.Command("hugo", "--watch", "-D", "-d", ref.tmpdir)
		hugoCmd.Dir = ch.Site.Root
		err = hugoCmd.Start()
		if err != nil {
			return nil, fmt.Errorf("error starting hugo: %v", err)
		}

		go func() {
			ticker := time.NewTicker(WebsocketFileTicker)
			idleTicks := 0

			defer func() {
				err := hugoCmd.Process.Signal(os.Interrupt)
				if err != nil {
					fmt.Println("error signaling to hugo:", err)
				}
				err = hugoCmd.Wait()
				if err != nil {
					fmt.Println("error waiting for hugo:", err)
				}
			}()

			for {
				<-ticker.C
				ch.mtx.Lock()

				err := ioutil.WriteFile(name, []byte(ref.doc.Contents()), 0644)
				if err != nil {
					fmt.Println("error saving document contents:", err)
				}

				if ref.clients == 0 {
					idleTicks++
					idleTime := time.Duration(idleTicks) * WebsocketFileTicker
					if idleTime >= IdleWebsocketTimeout {
						err := ch.Publish()
						fmt.Printf("idle for %v, quitting\n", idleTime)
						if err != nil {
							fmt.Printf(", error publishing: %v\n", err)
						}

						ref.doc.Close()
						os.RemoveAll(tmpdir)
						delete(ch.docs, name)
						ch.mtx.Unlock()
						return
					}
				} else {
					idleTicks = 0
				}
				ch.mtx.Unlock()
			}
		}()
	}

	return ch.docs[name], nil
}

func (ch *CaddyHugo) Publish() error {
	cmd := exec.Command("hugo")
	cmd.Dir = ch.Site.Root
	_, err := cmd.CombinedOutput()
	if err != nil {
		return err
	}

	return nil
}

func (ch *CaddyHugo) DeltaWebsocket(w http.ResponseWriter, r *http.Request) (int, error) {
	var upgrader = websocket.Upgrader{
		ReadBufferSize:  1024,
		WriteBufferSize: 1024,
	}

	conn, err := upgrader.Upgrade(w, r, nil)
	if err != nil {
		fmt.Println(err)
		return http.StatusBadRequest, err
	}

	doc, err := ch.doc(r)
	if err != nil {
		fmt.Println(err)
		return http.StatusBadRequest, err
	}

	const idlePing = 15 * time.Second
	const idlePingShort = 1 * time.Millisecond
	var timer *time.Timer

	timer = time.AfterFunc(idlePing, func() {
		conn.WriteJSON(Message{
			Deltas: []acedoc.Delta{},
			LTime:  ch.LTime(),
		})
		timer.Reset(idlePing)
	})

	client := doc.doc.Client(acedoc.DeltaHandlerFunc(func(ds []acedoc.Delta) error {
		timer.Reset(idlePing)
		err := conn.WriteJSON(Message{
			Deltas: ds,
			LTime:  ch.LTime(),
		})
		return err
	}))

	ch.mtx.Lock()
	doc.clients++
	ch.mtx.Unlock()

	defer func() {
		ch.mtx.Lock()
		client.Close()
		doc.clients--
		ch.mtx.Unlock()
	}()

	for {
		var message Message
		err := conn.ReadJSON(&message)
		if err != nil {
			return http.StatusBadRequest, err
		}

		ch.ObserveLTime(message.LTime)
		timer.Reset(idlePingShort)

		err = client.PushDeltas(message.Deltas...)
		if err != nil {
			return http.StatusBadRequest, err
		}

	}
}

type Message struct {
	Deltas []acedoc.Delta `json:"deltas"`
	LTime  uint64         `json:"ltime"`
}

func (ch CaddyHugo) NewContent(w http.ResponseWriter, r *http.Request) (int, error) {
	name := r.FormValue("name")
	ctype := r.FormValue("type")

	if filepath.Ext(name) != ".md" {
		name += ".md"
	}

	filename := path.Join(ctype, name)
	if ctype == "default" {
		filename = name
	}

	cmd := exec.Command("hugo", "new", filename)
	cmd.Dir = ch.Site.Root
	out, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Println("error running hugo:\n", string(out))
		return http.StatusInternalServerError, err
	}

	// serve redirect
	http.Redirect(w, r, filepath.Join("/hugo/edit/", "content", filename), http.StatusFound)
	return http.StatusFound, nil
}

func (ch CaddyHugo) TmplData(r *http.Request, docref *docref) interface{} {
	var doc *acedoc.Document
	if docref != nil {
		doc = docref.doc
	}
	if ch.HugoSites != nil && ch.HugoSites.Fs != nil {
		ch.HugoSites.Fs.Destination = afero.NewMemMapFs()
		ch.Build()
	}
	return tmplData{ch.Site, r, ch, doc, docref}
}