package handlers

import (
	"fmt"
	"net/http"
	"path/filepath"

	"github.com/debridmediamanager/zurg/internal/config"
	"github.com/debridmediamanager/zurg/internal/dav"
	intHttp "github.com/debridmediamanager/zurg/internal/http"
	"github.com/debridmediamanager/zurg/internal/torrent"
	"github.com/debridmediamanager/zurg/internal/universal"
	"github.com/debridmediamanager/zurg/internal/version"
	"github.com/debridmediamanager/zurg/pkg/logutil"
	"github.com/debridmediamanager/zurg/pkg/realdebrid"
	"github.com/go-chi/chi/v5"
)

type Handlers struct {
	getfile *universal.GetFile
	torMgr  *torrent.TorrentManager
	cfg     config.ConfigInterface
	api     *realdebrid.RealDebrid
	log     *logutil.Logger
}

func init() {
	chi.RegisterMethod("PROPFIND")
	chi.RegisterMethod("MKCOL")
	chi.RegisterMethod("MOVE")
}

func AttachHandlers(router *chi.Mux, getfile *universal.GetFile, torMgr *torrent.TorrentManager, cfg config.ConfigInterface, api *realdebrid.RealDebrid, log *logutil.Logger) {
	hs := &Handlers{
		getfile: getfile,
		torMgr:  torMgr,
		cfg:     cfg,
		api:     api,
		log:     log,
	}

	router.Use(globalOptionsHandler)

	router.Get("/", hs.handleHome)
	router.Get("/{mountType}/version.txt", hs.handleVersionFile)

	router.Get("/http/", hs.handleHttpRoot)
	router.Get("/http/{directory}/", hs.handleHttpTorrentsList)
	router.Get("/http/{directory}/{torrent}/", hs.handleHttpFilesList)
	router.Get("/http/{directory}/{torrent}/{file}", hs.universalDownloadFileHandler)
	router.Head("/http/{directory}/{torrent}/{file}", hs.httpHeadHandler)

	router.Get("/dav/", hs.handleDavRoot)
	router.Get("/dav/{directory}/", hs.handleDavTorrentsList)
	router.Get("/dav/{directory}/{torrent}/", hs.handleDavFilesList)
	router.Get("/dav/{directory}/{torrent}/{file}", hs.universalDownloadFileHandler)
	router.MethodFunc("PROPFIND", "/dav/", hs.handleDavRoot)
	router.MethodFunc("PROPFIND", "/dav/{directory}/", hs.handleDavTorrentsList)
	router.MethodFunc("PROPFIND", "/dav/{directory}/{torrent}/", hs.handleDavFilesList)
	router.MethodFunc("PROPFIND", "/dav/{directory}/{torrent}/{file}", hs.davCheckSingleFileHandler)

	router.Get("/infuse/", hs.handleInfuseRoot)
	router.Get("/infuse/{directory}/", hs.handleInfuseTorrentsList)
	router.Get("/infuse/{directory}/{torrent}/", hs.handleInfuseFilesList)
	router.Get("/infuse/{directory}/{torrent}/{file}", hs.universalDownloadFileHandler)
	router.MethodFunc("PROPFIND", "/infuse/", hs.handleInfuseRoot)
	router.MethodFunc("PROPFIND", "/infuse/{directory}/", hs.handleInfuseTorrentsList)
	router.MethodFunc("PROPFIND", "/infuse/{directory}/{torrent}/", hs.handleInfuseFilesList)

	// note: reused handlers for dav and infuse
	router.Delete("/{mountType}/{directory}/{torrent}/", hs.deleteTorrentHandler)
	router.Delete("/{mountType}/{directory}/{torrent}/{file}", hs.deleteFileHandler)
	router.MethodFunc("MKCOL", "/{mountType}/{directory}/{torrent}/", hs.mkcolTorrentHandler)
	router.MethodFunc("MOVE", "/{mountType}/{directory}/{torrent}/", hs.moveTorrentHandler)
	router.MethodFunc("MOVE", "/{mountType}/{directory}/{torrent}/{file}", hs.moveFileHandler)

	// logs route
	router.Get("/logs", hs.logsHandler)
	router.Get("/logs/", hs.logsHandler)

	router.MethodNotAllowed(func(resp http.ResponseWriter, req *http.Request) {
		hs.log.Debugf("Method not allowed: %s %s %v", req.Method, req.URL, req.Header)
		http.Error(resp, "Method not allowed", http.StatusMethodNotAllowed)
	})
}

// handle root request

func (hs *Handlers) innerRootHandler(resp http.ResponseWriter, req *http.Request, handleFunc func(*torrent.TorrentManager) ([]byte, error), contentType string) {
	out, err := handleFunc(hs.torMgr)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", contentType)
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (hs *Handlers) handleHttpRoot(resp http.ResponseWriter, req *http.Request) {
	hs.innerRootHandler(resp, req, intHttp.ServeRootDirectory, "text/html; charset=\"utf-8\"")
}

func (hs *Handlers) handleDavRoot(resp http.ResponseWriter, req *http.Request) {
	hs.innerRootHandler(resp, req, dav.ServeRootDirectory, "text/xml; charset=\"utf-8\"")
}

func (hs *Handlers) handleInfuseRoot(resp http.ResponseWriter, req *http.Request) {
	hs.innerRootHandler(resp, req, dav.ServeRootDirectoryForInfuse, "text/xml; charset=\"utf-8\"")
}

// handle torrent list request

func (hs *Handlers) innerTorrentsListHandler(resp http.ResponseWriter, req *http.Request, handleFunc func(string, *torrent.TorrentManager) ([]byte, error), contentType string) {
	directory := chi.URLParam(req, "directory")
	out, err := handleFunc(directory, hs.torMgr)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", contentType)
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (hs *Handlers) handleHttpTorrentsList(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	handlerFunc := intHttp.ServeTorrentsList
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return intHttp.ServeDownloadsList(torMgr)
		}
	}
	hs.innerTorrentsListHandler(resp, req, handlerFunc, "text/html; charset=\"utf-8\"")
}

func (hs *Handlers) handleDavTorrentsList(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	handlerFunc := dav.ServeTorrentsList
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return dav.ServeDownloadsList(torMgr)
		}
	}
	hs.innerTorrentsListHandler(resp, req, handlerFunc, "text/xml; charset=\"utf-8\"")
}

func (hs *Handlers) handleInfuseTorrentsList(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	handlerFunc := dav.ServeTorrentsListForInfuse
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return dav.ServeDownloadsListForInfuse(torMgr)
		}
	}
	hs.innerTorrentsListHandler(resp, req, handlerFunc, "text/xml; charset=\"utf-8\"")
}

// handle files list request

func (hs *Handlers) innerFilesListHandler(resp http.ResponseWriter, req *http.Request, handleFunc func(string, string, *torrent.TorrentManager) ([]byte, error), contentType string) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	out, err := handleFunc(directory, torrentName, hs.torMgr)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", contentType)
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (hs *Handlers) handleHttpFilesList(resp http.ResponseWriter, req *http.Request) {
	hs.innerFilesListHandler(resp, req, intHttp.ServeFilesList, "text/html; charset=\"utf-8\"")
}

func (hs *Handlers) handleDavFilesList(resp http.ResponseWriter, req *http.Request) {
	hs.innerFilesListHandler(resp, req, dav.ServeFilesList, "text/xml; charset=\"utf-8\"")
}

func (hs *Handlers) handleInfuseFilesList(resp http.ResponseWriter, req *http.Request) {
	hs.innerFilesListHandler(resp, req, dav.ServeFilesListForInfuse, "text/xml; charset=\"utf-8\"")
}

func (hs *Handlers) handleVersionFile(resp http.ResponseWriter, req *http.Request) {
	out, _ := version.GetFile()
	resp.Header().Set("Content-Type", "text/plain; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (hs *Handlers) deleteFileHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	fileName := chi.URLParam(req, "file")
	if dav.HandleDeleteFile(directory, torrentName, fileName, hs.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func (hs *Handlers) deleteTorrentHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	if dav.HandleDeleteTorrent(directory, torrentName, hs.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func (hs *Handlers) davCheckSingleFileHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	fileName := chi.URLParam(req, "file")
	out, err := dav.HandleSingleFile(directory, torrentName, fileName, hs.torMgr)
	if err != nil {
		fmt.Println(">>>>>>>>>>>>>>>>>>>. not found", err)
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	fmt.Println(">>>>>>>>>>>>>>>>>>>. found yey")
	resp.Header().Set("Content-Type", "text/xml; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (hs *Handlers) mkcolTorrentHandler(resp http.ResponseWriter, req *http.Request) {
	fmt.Println(">>>>>>>>>>>>>>>>>>> mkcolTorrentHandler")
	resp.WriteHeader(http.StatusNoContent)
}

func (hs *Handlers) moveFileHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	fileName := chi.URLParam(req, "file")
	newName := req.Header.Get("Destination")
	newName = filepath.Base(newName)
	fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler", fileName, ">>>>>>>>", newName)
	if dav.HandleRenameFile(directory, torrentName, fileName, newName, hs.torMgr) != nil {
		fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler not found")
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler yay")
	resp.WriteHeader(http.StatusNoContent)
}

func (hs *Handlers) moveTorrentHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	newName := req.Header.Get("Destination")
	newName = filepath.Base(newName)
	if dav.HandleRenameTorrent(directory, torrentName, newName, hs.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func globalOptionsHandler(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method == "OPTIONS" {
			w.WriteHeader(http.StatusOK)
			return
		}
		next.ServeHTTP(w, r)
	})
}

func (hs *Handlers) universalDownloadFileHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	fileName := chi.URLParam(req, "file")
	hs.getfile.ServeFile(directory, torrentName, fileName, resp, req, hs.torMgr, hs.cfg, hs.log)
}

func (hs *Handlers) httpHeadHandler(resp http.ResponseWriter, req *http.Request) {
	directory := chi.URLParam(req, "directory")
	torrentName := chi.URLParam(req, "torrent")
	fileName := chi.URLParam(req, "file")
	universal.HandleHeadRequest(directory, torrentName, fileName, resp, req, hs.torMgr, hs.log)
}

func (hs *Handlers) logsHandler(resp http.ResponseWriter, req *http.Request) {
	logs, err := hs.log.GetLogsFromFile()
	if err != nil {
		http.Error(resp, err.Error(), http.StatusInternalServerError)
		return
	}
	fmt.Fprint(resp, logs)
}

func bToMb(b uint64) uint64 {
	return b / 1024 / 1024
}