package router

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/pkg/logutil"
	"github.com/debridmediamanager/zurg/pkg/realdebrid"
	"github.com/julienschmidt/httprouter"
)

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

func ApplyRouteTable(router *httprouter.Router, getfile *universal.GetFile, torMgr *torrent.TorrentManager, cfg config.ConfigInterface, api *realdebrid.RealDebrid, log *logutil.Logger) {
	zr := &ZurgRouter{
		getfile: getfile,
		torMgr:  torMgr,
		cfg:     cfg,
		api:     api,
		log:     log,
	}

	// file download handler
	router.GET("/http/:directory/:torrent/:file", zr.universalDownloadFileHandler)
	router.GET("/dav/:directory/:torrent/:file", zr.universalDownloadFileHandler)
	router.GET("/infuse/:directory/:torrent/:file", zr.universalDownloadFileHandler)
	// HEAD route
	router.HEAD("/http/:directory/:torrent/:file", zr.httpHeadHandler)

	// HTTP router
	router.GET("/http/", zr.httpRootHandler)
	router.GET("/http/:directory/", zr.httpTorrentsListHandler)
	router.GET("/http/:directory/:torrent/", zr.httpFilesListHandler)

	// INFUSE DAV routes
	router.Handle("PROPFIND", "/infuse/", zr.infuseDavRootHandler)
	router.Handle("PROPFIND", "/infuse/:directory/", zr.infuseDavTorrentsListHandler)
	router.Handle("PROPFIND", "/infuse/:directory/:torrent/", zr.infuseDavFilesListHandler)

	// WEBDAV router
	router.Handle("PROPFIND", "/dav/", zr.davRootHandler)
	router.Handle("PROPFIND", "/dav/:directory/", zr.davTorrentsListHandler)
	router.Handle("PROPFIND", "/dav/:directory/:torrent/", zr.davFilesListHandler)
	// EXTRA: for browser handling
	router.GET("/dav/", zr.davRootHandler)
	router.GET("/dav/:directory/", zr.davTorrentsListHandler)
	router.GET("/dav/:directory/:torrent/", zr.davFilesListHandler)
	// EXTRA: for browser handling of infuse
	router.GET("/infuse/", zr.infuseDavRootHandler)
	router.GET("/infuse/:directory/", zr.infuseDavTorrentsListHandler)
	router.GET("/infuse/:directory/:torrent/", zr.infuseDavFilesListHandler)
	// DELETE routes
	router.DELETE("/dav/:directory/:torrent/", zr.deleteTorrentHandler)
	router.DELETE("/dav/:directory/:torrent/:file", zr.deleteFileHandler)
	// RENAME sequence
	router.Handle("PROPFIND", "/dav/:directory/:torrent/:file", zr.davCheckSingleFileHandler)
	router.Handle("MKCOL", "/dav/:directory/:torrent/", zr.mkcolTorrentHandler)
	router.Handle("MOVE", "/dav/:directory/:torrent/:file", zr.moveFileHandler)
	router.Handle("MOVE", "/dav/:directory/:torrent/", zr.moveTorrentHandler)

	// Global OPTIONS route
	router.GlobalOPTIONS = http.HandlerFunc(zr.globalOptionsHandler)

	// root route
	router.GET("/", zr.rootHandler)

	// logs route
	router.GET("/logs", zr.logsHandler)
	router.GET("/logs/", zr.logsHandler)

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

func (zr *ZurgRouter) handleRootRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(*torrent.TorrentManager) ([]byte, error), contentType string) {
	out, err := handleFunc(zr.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 (zr *ZurgRouter) httpRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	zr.handleRootRequest(resp, req, params, intHttp.ServeRootDirectory, "text/html; charset=\"utf-8\"")
}

func (zr *ZurgRouter) davRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	zr.handleRootRequest(resp, req, params, dav.ServeRootDirectory, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) infuseDavRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	zr.handleRootRequest(resp, req, params, dav.ServeRootDirectoryForInfuse, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) handleTorrentsListRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(string, *torrent.TorrentManager) ([]byte, error), contentType string) {
	directory := params.ByName("directory")
	out, err := handleFunc(directory, zr.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 (zr *ZurgRouter) httpTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	handlerFunc := intHttp.ServeTorrentsList
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return intHttp.ServeDownloadsList(torMgr)
		}
	}
	zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/html; charset=\"utf-8\"")
}

func (zr *ZurgRouter) davTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	handlerFunc := dav.ServeTorrentsList
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return dav.ServeDownloadsList(torMgr)
		}
	}
	zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) infuseDavTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	handlerFunc := dav.ServeTorrentsListForInfuse
	if directory == config.DOWNLOADS {
		handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
			return dav.ServeDownloadsListForInfuse(torMgr)
		}
	}
	zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) handleFilesListRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(string, string, *torrent.TorrentManager) ([]byte, error), contentType string) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	out, err := handleFunc(directory, torrentName, zr.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 (zr *ZurgRouter) httpFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	zr.handleFilesListRequest(resp, req, params, intHttp.ServeFilesList, "text/html; charset=\"utf-8\"")
}

func (zr *ZurgRouter) davFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	zr.handleFilesListRequest(resp, req, params, dav.ServeFilesList, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) infuseDavFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	fmt.Println(">>>>>>>>>>>>>>>>>>> infuseDavFilesListHandler", params.ByName("directory"), params.ByName("torrent"))
	zr.handleFilesListRequest(resp, req, params, dav.ServeFilesListForInfuse, "text/xml; charset=\"utf-8\"")
}

func (zr *ZurgRouter) deleteFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	fileName := params.ByName("file")
	if dav.HandleDeleteFile(directory, torrentName, fileName, zr.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func (zr *ZurgRouter) deleteTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	if dav.HandleDeleteTorrent(directory, torrentName, zr.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func (zr *ZurgRouter) davCheckSingleFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	fileName := params.ByName("file")
	out, err := dav.HandleSingleFile(directory, torrentName, fileName, zr.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 (zr *ZurgRouter) mkcolTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	fmt.Println(">>>>>>>>>>>>>>>>>>> mkcolTorrentHandler")
	resp.WriteHeader(http.StatusNoContent)
}

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

func (zr *ZurgRouter) moveTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	newName := req.Header.Get("Destination")
	newName = filepath.Base(newName)
	if dav.HandleRenameTorrent(directory, torrentName, newName, zr.torMgr) != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.WriteHeader(http.StatusNoContent)
}

func (zr *ZurgRouter) globalOptionsHandler(resp http.ResponseWriter, req *http.Request) {
	resp.WriteHeader(http.StatusOK)
}

func (zr *ZurgRouter) universalDownloadFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	fileName := params.ByName("file")
	zr.getfile.ServeFile(directory, torrentName, fileName, resp, req, zr.torMgr, zr.cfg, zr.log)
}

func (zr *ZurgRouter) httpHeadHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	fileName := params.ByName("file")
	universal.HandleHeadRequest(directory, torrentName, fileName, resp, req, zr.torMgr, zr.log)
}

func (zr *ZurgRouter) logsHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	logs, err := zr.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
}