package caddyhugo

import (
	"encoding/base64"
	"fmt"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"path"
	"time"

	"git.stephensearles.com/stephen/acedoc"
)

type editSession struct {
	clients  uint
	docname  string
	filename string
	doc      *acedoc.Document
	tmpdir   string
}

func (ch *CaddyHugo) newEditSession(docName string) (*editSession, error) {
	filename := ch.docFilename(docName)

	fmt.Println("opening", filename)
	contents, err := ioutil.ReadFile(filename)
	if err != nil {
		return nil, err
	}

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

	es := &editSession{
		docname:  docName,
		filename: filename,
		doc:      acedoc.NewString(string(contents)),
		tmpdir:   tmpdir,
	}

	err = es.doc.LogToFile(path.Join(ch.Dir, "logs", docName))
	if err != nil {
		fmt.Println(err)
		return nil, err
	}

	ch.docs[filename] = es

	ch.renderDraft(es)

	return es, nil
}

func (ch *CaddyHugo) renderDraft(es *editSession) error {
	hugoCmd := exec.Command("hugo", "--watch", "-D", "-d", es.tmpdir)
	hugoCmd.Dir = ch.Dir
	err := hugoCmd.Start()
	if err != nil {
		return 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(es.filename, []byte(es.doc.Contents()), 0644)
			if err != nil {
				fmt.Println("error saving document contents:", err)
			}

			if es.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)
					}

					es.doc.Close()
					os.RemoveAll(es.tmpdir)
					delete(ch.docs, es.filename)
					ch.mtx.Unlock()
					return
				} else {
					fmt.Println("idle for", idleTime)
				}
			} else {
				idleTicks = 0
			}
			ch.mtx.Unlock()
		}
	}()

	return nil
}

func (ch *CaddyHugo) hasEditSession(docName string) (*editSession, bool) {
	dr, ok := ch.docs[ch.docFilename(docName)]
	return dr, ok
}

func (ch *CaddyHugo) editSession(docName string) (*editSession, error) {
	ch.mtx.Lock()
	defer ch.mtx.Unlock()

	var err error

	dr, ok := ch.hasEditSession(docName)
	if !ok {
		dr, err = ch.newEditSession(docName)
	}

	return dr, err
}

func docNameFromEditRequest(r *http.Request) string {
	return r.URL.Path[len("/hugo/edit/"):]
}