package handlers

import (
	"crypto/sha256"
	"dwelling-upload/internal/configuration"
	"dwelling-upload/pkg/logging"
	"dwelling-upload/pkg/server"
	"dwelling-upload/pkg/utils"
	"embed"
	"encoding/base64"
	"encoding/hex"
	"fmt"
	"html/template"
	"io"
	"io/fs"
	"net/http"
	"net/url"
	"os"
	"path"
	"strings"
	"time"

	"github.com/Joker/jade"
)

var compiledTemplates map[string]*template.Template

//go:embed web/assets
var assetsDir embed.FS

//go:embed web/templates
var templatesDir embed.FS

type NotFoundData struct {
	MainSite string
}

type IndexData struct {
	MainSite         string
	FileMaxSz        string
	StorageCapacity  int64
	StorageUsed      int64
	StorageAvailable int64
	StorageCapStr    string
	StorageUsedStr   string
	StorageAvailStr  string
	KeepForHours     int
}

type UploadedData struct {
	MainSite     string
	DownloadURL  string
	KeepForHours int
}

type UploadHandlers struct {
	conf        *configuration.Configuration
	logErr      *logging.Logger
	logUpload   *logging.Logger
	logDownload *logging.Logger

	uploadDirSize *int64
}

func NewUploadHandlers(conf *configuration.Configuration, lErr, lUp, lDown *logging.Logger, uploadDirSize *int64) *UploadHandlers {
	compileTemplates(lErr)

	return &UploadHandlers{
		conf:          conf,
		logErr:        lErr,
		logUpload:     lUp,
		logDownload:   lDown,
		uploadDirSize: uploadDirSize}
}

func (*UploadHandlers) AssetsFS() http.FileSystem {
	f, _ := fs.Sub(assetsDir, "web/assets")
	return http.FS(f)
}

func (h *UploadHandlers) Index(w http.ResponseWriter, r *http.Request) {
	var storCapacity int64 = h.conf.Uploads.Limits.Storage << 20
	var fMaxSize int64 = h.conf.Uploads.Limits.FileSize << 20

	_, _, capStr := utils.ConvertFileSize(storCapacity)
	_, _, usedStr := utils.ConvertFileSize(*h.uploadDirSize)
	_, _, availStr := utils.ConvertFileSize(storCapacity - *h.uploadDirSize)
	_, _, fMaxSzStr := utils.ConvertFileSize(fMaxSize)

	if err := compiledTemplates["index"].Execute(w, &IndexData{
		MainSite:         utils.MainSite(r.Host),
		FileMaxSz:        fMaxSzStr,
		StorageCapacity:  storCapacity,
		StorageCapStr:    capStr,
		StorageAvailable: storCapacity - *h.uploadDirSize,
		StorageAvailStr:  availStr,
		StorageUsed:      *h.uploadDirSize,
		StorageUsedStr:   usedStr,
		KeepForHours:     h.conf.Uploads.Limits.KeepForHours,
	}); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		h.logErr.Fatalln("failed to execute Index template:", err)
	}
}

func (h *UploadHandlers) Upload(w http.ResponseWriter, r *http.Request) {
	var fMaxSizeBytes int64 = h.conf.Uploads.Limits.FileSize << 20
	var storCapacity int64 = h.conf.Uploads.Limits.Storage << 20

	r.Body = http.MaxBytesReader(w, r.Body, fMaxSizeBytes)

	if err := r.ParseMultipartForm(fMaxSizeBytes); err != nil {
		h.logErr.Println("failed to parse form:", err)
		http.Error(w, err.Error(), http.StatusExpectationFailed)
		return
	}

	f, fHandler, err := r.FormFile("file")
	if err != nil {
		h.logErr.Println("failed to open incoming file:", err)
		w.WriteHeader(http.StatusInternalServerError)
		http.Error(w, "cannot read incoming file", http.StatusInternalServerError)
		return
	}
	defer func() {
		os.Remove(fHandler.Filename)
		f.Close()
	}()

	var leftSpace int64 = storCapacity - *h.uploadDirSize

	if leftSpace < fHandler.Size {
		h.logErr.Println("not enough space left in storage, only", leftSpace>>20, "MiB left")
		w.WriteHeader(http.StatusInternalServerError)
		if err := compiledTemplates["nospace"].Execute(w, &NotFoundData{
			MainSite: utils.MainSite(r.Host),
		}); err != nil {
			h.logErr.Fatalln("failed to execute NoSpace template:", err)
			http.Error(w, "cannot execute a NoSpace template. But error was that there's no space for uploads left", http.StatusInternalServerError)
		}
	}

	s256 := sha256.New()
	if _, err := io.Copy(s256, f); err != nil {
		h.logErr.Println("failed to compute SHA-256 hash:", err)
		http.Error(w, "cannot compute hash for a file", http.StatusInternalServerError)
		return
	}

	fHash := hex.EncodeToString(s256.Sum(nil))
	s256.Write([]byte(h.conf.HashSalt))
	fSaltedHash := base64.RawURLEncoding.EncodeToString(s256.Sum(nil))

	f.Seek(0, io.SeekStart)

	fPath := path.Join(h.conf.Uploads.Directory, fSaltedHash)

	_, err = os.Stat(fPath)
	if os.IsNotExist(err) {
		fDst, err := os.Create(fPath)
		if err != nil {
			h.logErr.Println("failed to open file for writing", err)
			http.Error(w, "cannot create your file", http.StatusInternalServerError)
			return
		}
		defer fDst.Close()

		// We initialy set a dst file size to occupy space equal to uploaded's size.
		// This is called a sparse file, if you need to know.
		// It allows us to have a relatively small buffer size for inotify watcher.
		// And it really affects that. I tested it.
		fDst.Seek(fHandler.Size-1, io.SeekStart)
		fDst.Write([]byte{0})
		fDst.Seek(0, io.SeekStart)

		_, err = io.Copy(fDst, f)
		if err != nil {
			h.logErr.Println("failed to copy uploaded file to destination:", err)
			http.Error(w, "cannot copy file's content", http.StatusInternalServerError)
			return
		}

		typ, _ := utils.NetworkType(r.Host)

		h.logUpload.Printf("| %s | %s | %s | SHA256 %s | %s | %d | %s", r.Header.Get("X-Real-IP"), typ,
			fHandler.Filename, fHash, fSaltedHash, fHandler.Size, r.UserAgent())

		w.WriteHeader(http.StatusCreated)
	} else {
		os.Chtimes(fPath, time.Now(), time.Now())
		w.WriteHeader(http.StatusFound)
	}

	downloadURL := path.Join("/f", fSaltedHash, fHandler.Filename)
	downloadURLParsed, _ := url.Parse(downloadURL)

	if strings.Contains(r.UserAgent(), "curl") {
		_, scheme := utils.NetworkType(r.Host)
		w.Write([]byte(scheme + "://" + r.Host + downloadURLParsed.String() + "\r\n"))
		return
	}

	if err := compiledTemplates["uploaded"].Execute(w, &UploadedData{
		MainSite:     utils.MainSite(r.Host),
		DownloadURL:  downloadURLParsed.String(),
		KeepForHours: h.conf.Uploads.Limits.KeepForHours,
	}); err != nil {
		h.logErr.Fatalln("failed to execute Uploaded template:", err)
		http.Error(w, "cannot execute Uploaded template, but here is your download link: "+downloadURLParsed.String(), http.StatusInternalServerError)
	}
}

func (h *UploadHandlers) Download(w http.ResponseWriter, r *http.Request) {
	saltedHash := server.GetURLParam(r, "hash")

	path := path.Join(h.conf.Uploads.Directory, saltedHash)

	stat, err := os.Stat(path)
	if os.IsNotExist(err) {
		h.NotFound(w, r)
		return
	}

	name := server.GetURLParam(r, "name")

	w.Header().Add("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", name))

	fd, err := os.Open(path)
	if err != nil {
		h.logErr.Println("failed to open file to read:", err)
		w.WriteHeader(http.StatusInternalServerError)
		return
	}
	defer fd.Close()

	netTyp, _ := utils.NetworkType(r.Host)

	h.logDownload.Printf("| %s | %s | %s | %s | %s", r.Header.Get("X-Real-IP"), netTyp, name, saltedHash, r.UserAgent())

	http.ServeContent(w, r, path, stat.ModTime(), fd)
}

func (h *UploadHandlers) NotFound(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusNotFound)
	if err := compiledTemplates["404"].Execute(w, NotFoundData{
		MainSite: utils.MainSite(r.Host),
	}); err != nil {
		w.WriteHeader(http.StatusInternalServerError)
		h.logErr.Fatalln("failed to execute 404 template:", err)
	}
}

func compileTemplates(lErr *logging.Logger) {
	compiledTemplates = make(map[string]*template.Template)

	t, _ := fs.Sub(templatesDir, "web/templates")
	templatesFS := http.FS(t)

	indexStr, err := jade.ParseFileFromFileSystem("index.jade", templatesFS)
	if err != nil {
		lErr.Fatalln(err)
	}

	indexTpl, err := template.New("index").Parse(indexStr)
	if err != nil {
		lErr.Fatalln(err)
	}

	compiledTemplates["index"] = indexTpl

	uploadedStr, err := jade.ParseFileFromFileSystem("uploaded.jade", templatesFS)
	if err != nil {
		lErr.Fatalln(err)
	}

	uploadedTpl, err := template.New("uploaded").Parse(uploadedStr)
	if err != nil {
		lErr.Fatalln(err)
	}

	compiledTemplates["uploaded"] = uploadedTpl

	notfoundStr, err := jade.ParseFileFromFileSystem("404.jade", templatesFS)
	if err != nil {
		lErr.Fatalln(err)
	}

	notfoundTpl, err := template.New("404").Parse(notfoundStr)
	if err != nil {
		lErr.Fatalln(err)
	}

	compiledTemplates["404"] = notfoundTpl

	nospaceStr, err := jade.ParseFileFromFileSystem("nospace.jade", templatesFS)
	if err != nil {
		lErr.Fatalln(err)
	}

	nospaceTpl, err := template.New("nospace").Parse(nospaceStr)
	if err != nil {
		lErr.Fatalln(err)
	}

	compiledTemplates["nospace"] = nospaceTpl
}