package server

import (
	"bytes"
	"errors"
	"fmt"
	"html/template"
	"io"
	"log/slog"
	"net/http"
	"strconv"
	"strings"

	"github.com/gorilla/mux"

	"git.riou.xyz/jriou/coller/internal"
)

type PageData struct {
	Title                  string
	Version                string
	Expirations            []int
	Expiration             int
	Language               string
	Languages              []string
	Err                    error
	URL                    string
	Note                   *Note
	EnableUploadFileButton bool
	AceDirectory           string
	BootstrapDirectory     string
	DisableEditor          bool
}

type HomeHandler struct {
	Templates *template.Template
	PageData  PageData
}

func (h *HomeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.Templates.ExecuteTemplate(w, "index", h.PageData)
}

type CreateNoteWithFormHandler struct {
	Templates     *template.Template
	PageData      PageData
	logger        *slog.Logger
	db            *Database
	maxUploadSize int64
}

func (h *CreateNoteWithFormHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.PageData.Err = nil
	templateName := "create"

	h.logger.Debug("parsing multipart form")
	err := r.ParseMultipartForm(h.maxUploadSize)
	if err != nil {
		h.PageData.Err = err
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	h.logger.Debug("parsing content")
	content := []byte(r.FormValue("content"))

	h.logger.Debug("parsing file")
	file, handler, err := r.FormFile("file")
	if err != nil && !errors.Is(err, http.ErrMissingFile) {
		h.PageData.Err = err
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	if !errors.Is(err, http.ErrMissingFile) {
		defer file.Close()

		h.logger.Debug("checking file size")
		if handler.Size > h.maxUploadSize {
			h.PageData.Err = fmt.Errorf("file too large (%d > %d)", handler.Size, h.maxUploadSize)
			h.Templates.ExecuteTemplate(w, templateName, h.PageData)
			return
		}

		h.logger.Debug("checking file content type")
		if !strings.HasPrefix(handler.Header.Get("Content-Type"), "text/") {
			h.PageData.Err = fmt.Errorf("text file expected (got %s)", handler.Header.Get("Content-Type"))
			h.Templates.ExecuteTemplate(w, templateName, h.PageData)
			return
		}

		h.logger.Debug("reading uploaded file")
		var fileContent bytes.Buffer
		n, err := io.Copy(&fileContent, file)
		if err != nil {
			h.PageData.Err = err
			h.Templates.ExecuteTemplate(w, templateName, h.PageData)
			return
		}

		h.logger.Debug("file uploaded", slog.Any("bytes", n))
		if n != 0 {
			content = fileContent.Bytes()
		}
	}

	h.logger.Debug("checking content")
	if content == nil || len(content) == 0 {
		h.PageData.Err = fmt.Errorf("empty note")
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	h.logger.Debug("checking inputs")
	noEncryption := r.FormValue("no-encryption")
	encryptionKey := r.FormValue("encryption-key")
	expiration := r.FormValue("expiration")
	deleteAfterRead := r.FormValue("delete-after-read")
	language := r.FormValue("language")

	if encryptionKey == "" && noEncryption == "" {
		h.logger.Debug("generating encryption key")
		encryptionKey = internal.GenerateChars(encryptionKeyLength)
	}

	h.logger.Debug("computing expiration")
	var expirationInt int
	if expiration == "Expiration" {
		expirationInt = 0
	} else {
		expirationInt, _ = strconv.Atoi(expiration)
	}

	h.logger.Debug("saving note to the database")
	note, err := h.db.Create(content, encryptionKey, encryptionKey != "", expirationInt, deleteAfterRead != "", language)
	if err != nil {
		h.PageData.Err = err
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	h.logger.Debug("building note url")
	var scheme = "http://"
	if r.TLS != nil {
		scheme = "https://"
	}

	h.PageData.URL = fmt.Sprintf("%s%s/%s", scheme, r.Host, note.ID)
	if encryptionKey != "" {
		h.PageData.URL += "/" + encryptionKey
	}

	h.logger.Debug("rendering page")
	h.Templates.ExecuteTemplate(w, "create", h.PageData)
}

type GetWebNoteHandler struct {
	Templates *template.Template
	PageData  PageData
	logger    *slog.Logger
	db        *Database
}

func (h *GetWebNoteHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.PageData.Err = nil
	templateName := "note"

	vars := mux.Vars(r)
	id := vars["id"]

	note, err := h.db.Get(id)

	if err != nil {
		h.PageData.Err = fmt.Errorf("could not find note: %v", err)
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	if note == nil {
		h.PageData.Err = fmt.Errorf("note doesn't exist or has been deleted")
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	if note.Encrypted {
		h.PageData.Err = fmt.Errorf("note is encrypted")
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	h.PageData.Note = note

	h.logger.Debug("rendering note web page")
	h.Templates.ExecuteTemplate(w, "note", h.PageData)
}

func (h *GetEncryptedWebNoteHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.PageData.Err = nil
	templateName := "note"

	vars := mux.Vars(r)
	id := vars["id"]
	encryptionKey := vars["encryptionKey"]

	note, err := h.db.Get(id)

	if err != nil {
		h.PageData.Err = fmt.Errorf("could not find note: %v", err)
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	if note == nil {
		h.PageData.Err = fmt.Errorf("note doesn't exist or has been deleted")
		h.Templates.ExecuteTemplate(w, templateName, h.PageData)
		return
	}

	if encryptionKey != "" && note.Encrypted {
		note.Content, err = internal.Decrypt(note.Content, encryptionKey)
		if err != nil {
			h.PageData.Err = fmt.Errorf("could not decrypt note: %v", err)
			h.Templates.ExecuteTemplate(w, templateName, h.PageData)
			return
		}
	}

	h.PageData.Note = note

	h.logger.Debug("rendering encrypted note web page")
	h.Templates.ExecuteTemplate(w, "note", h.PageData)
}

func (h *ClientsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.logger.Debug("rendering clients web page")
	h.Templates.ExecuteTemplate(w, "clients", h.PageData)
}