package router

import (
	"fmt"
	"net/http"
	"os"
	"path/filepath"
	"runtime"
	"strings"

	"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/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,
	}

	// http router
	router.GET("/http/:directory/:torrent/:file", zr.universalDownloadFileHandler)
	router.GET("/http/:directory/:torrent/", zr.httpTorrentDirectoryHandler)
	router.GET("/http/:directory/", zr.httpDirectoryHandler)
	router.GET("/http/", zr.httpRootHandler)
	// HEAD route
	router.HEAD("/http/:directory/:torrent/:file", zr.headFileHandler)

	// dav router
	router.GET("/dav/:directory/:torrent/:file", zr.universalDownloadFileHandler)
	router.GET("/dav/:directory/:torrent/", zr.propfindTorrentHandler)
	router.GET("/dav/:directory/", zr.propfindDirectoryHandler)
	router.GET("/dav/", zr.propfindRootHandler)
	// PROPFIND routes
	router.Handle("PROPFIND", "/dav/:directory/:torrent/", zr.propfindTorrentHandler)
	router.Handle("PROPFIND", "/dav/:directory/", zr.propfindDirectoryHandler)
	router.Handle("PROPFIND", "/dav/", zr.propfindRootHandler)
	// DELETE routes
	router.DELETE("/dav/:directory/:torrent/:file", zr.deleteFileHandler)
	router.DELETE("/dav/:directory/:torrent/", zr.deleteTorrentHandler)
	// rename sequence
	router.Handle("PROPFIND", "/dav/:directory/:torrent/:file", zr.propfindFileHandler)
	router.Handle("MKCOL", "/dav/:directory/:torrent/", zr.mkcolTorrentHandler)
	router.Handle("MOVE", "/dav/:directory/:torrent/:file", zr.moveFileHandler)
	// MOVE routes
	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) httpTorrentDirectoryHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	out, err := intHttp.HandleListFiles(directory, torrentName, zr.torMgr, zr.log)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/html; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	fmt.Fprint(resp, *out)
}

func (zr *ZurgRouter) httpDirectoryHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	out, err := intHttp.HandleListTorrents(directory, zr.torMgr, zr.log)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/html; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	fmt.Fprint(resp, *out)
}

func (zr *ZurgRouter) httpRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	out, err := intHttp.HandleListDirectories(zr.torMgr)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/html; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	fmt.Fprint(resp, *out)
}

func (zr *ZurgRouter) propfindFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	fileName := params.ByName("file")
	out, err := dav.HandlePropfindFile(directory, torrentName, fileName, zr.torMgr, zr.log)
	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) propfindTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	torrentName := params.ByName("torrent")
	out, err := dav.HandleListFiles(directory, torrentName, zr.torMgr, zr.log)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/xml; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (zr *ZurgRouter) propfindDirectoryHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	directory := params.ByName("directory")
	out, err := dav.HandleListTorrents(directory, zr.torMgr, zr.log)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/xml; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

func (zr *ZurgRouter) propfindRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	out, err := dav.HandleListDirectories(zr.torMgr)
	if err != nil {
		http.Error(resp, "Not Found", http.StatusNotFound)
		return
	}
	resp.Header().Set("Content-Type", "text/xml; charset=\"utf-8\"")
	resp.WriteHeader(http.StatusOK)
	resp.Write(out)
}

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) 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.HandleGetRequest(directory, torrentName, fileName, resp, req, zr.torMgr, zr.cfg, zr.log)
}

func (zr *ZurgRouter) headFileHandler(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)
}

type SponsorResponse struct {
	Patreon string `json:"patreon"`
	Github  string `json:"github"`
	Paypal  string `json:"paypal"`
}
type RootResponse struct {
	Version    string            `json:"version"`
	BuiltAt    string            `json:"built_at"`
	GitCommit  string            `json:"git_commit"`
	Dav        string            `json:"dav"`
	Html       string            `json:"html"`
	Logs       string            `json:"logs"`
	UserInfo   *realdebrid.User  `json:"user_info"`    // Replace UserInfoType with the actual type
	MemAlloc   uint64            `json:"mem_alloc"`    // Memory allocation in MB
	TotalAlloc uint64            `json:"total_alloc"`  // Total memory allocated in MB
	Sys        uint64            `json:"sys"`          // System memory in MB
	NumGC      uint32            `json:"num_gc"`       // Number of completed GC cycles
	PID        int               `json:"pid"`          // Process ID
	Sponsor    SponsorResponse   `json:"sponsor_zurg"` // Sponsorship links
	Config     config.ZurgConfig `json:"config"`
}

func (zr *ZurgRouter) rootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
	userInfo, err := zr.api.GetUserInformation()
	if err != nil {
		http.Error(resp, err.Error(), http.StatusInternalServerError)
		return
	}

	var mem runtime.MemStats
	runtime.ReadMemStats(&mem)

	response := RootResponse{
		Version:    version.GetVersion(),
		BuiltAt:    version.GetBuiltAt(),
		GitCommit:  version.GetGitCommit(),
		Dav:        fmt.Sprintf("//%s/dav/", req.Host),
		Html:       fmt.Sprintf("//%s/http/", req.Host),
		Logs:       fmt.Sprintf("//%s/logs/", req.Host),
		UserInfo:   userInfo,
		MemAlloc:   bToMb(mem.Alloc),
		TotalAlloc: bToMb(mem.TotalAlloc),
		Sys:        bToMb(mem.Sys),
		NumGC:      mem.NumGC,
		PID:        os.Getpid(),
		Sponsor: SponsorResponse{
			Patreon: "https://www.patreon.com/debridmediamanager",
			Github:  "https://github.com/sponsors/debridmediamanager",
			Paypal:  "https://paypal.me/yowmamasita",
		},
		Config: zr.cfg.GetConfig(),
	}

	out := `<table border="1px">
    <tr>
        <th colspan="3">zurg</th>
    </tr>
    <tr>
        <td>Version</td>
        <td colspan="2">%s</td>
    </tr>
    <tr>
        <td>Built At</td>
        <td colspan="2">%s</td>
    </tr>
    <tr>
        <td>Git Commit</td>
        <td colspan="2">%s</td>
    </tr>
    <tr>
        <td>DAV</td>
        <td colspan="2"><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td>HTML</td>
        <td colspan="2"><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td>Logs</td>
        <td colspan="2"><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td>Memory Allocation</td>
        <td colspan="2">%d MB</td>
    </tr>
    <tr>
        <td>Total Memory Allocated</td>
        <td colspan="2">%d MB</td>
    </tr>
    <tr>
        <td>System Memory</td>
        <td colspan="2">%d MB</td>
    </tr>
    <tr>
        <td>Number of GC Cycles</td>
        <td colspan="2">%d</td>
    </tr>
    <tr>
        <td>Process ID</td>
        <td colspan="2">%d</td>
    </tr>
    <tr>
        <td rowspan="3">Sponsor Zurg</td>
        <td>Patreon</td>
		<td><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td>Github</td>
		<td><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td>Paypal</td>
		<td><a href="%s">%s</a></td>
    </tr>
    <tr>
        <td rowspan="6">User Info</td>
        <td>Username</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Points</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Locale</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Type</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Premium</td>
		<td>%d seconds</td>
    </tr>
    <tr>
        <td>Expiration</td>
		<td>%s</td>
    </tr>
    <tr>
        <td rowspan="20">Config</td>
        <td>Version</td>
        <td>%s</td>
    </tr>
    <tr>
        <td>Token</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Host</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Port</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Number of Workers</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Refresh Every Seconds</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Retain RD Torrent Name</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Retain Folder Name Extension</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Can Repair</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Delete Rar Files</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>RealDebrid Timeout</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Use Download Cache</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Rate Limit Sleep Seconds</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Retries Until Failed</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Preferred Hosts</td>
		<td>%s</td>
    </tr>
    <tr>
        <td>Network Buffer Size</td>
		<td>%d</td>
    </tr>
    <tr>
        <td>Serve From Rclone</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Verify Download Link</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>Force IPv6</td>
		<td>%t</td>
    </tr>
    <tr>
        <td>On Library Update</td>
		<td>%s</td>
    </tr>
</table>
`
	out = fmt.Sprintf(out,
		response.Version,
		response.BuiltAt,
		response.GitCommit,
		response.Dav,
		response.Dav,
		response.Html,
		response.Html,
		response.Logs,
		response.Logs,
		response.MemAlloc,
		response.TotalAlloc,
		response.Sys,
		response.NumGC,
		response.PID,
		response.Sponsor.Patreon,
		response.Sponsor.Patreon,
		response.Sponsor.Github,
		response.Sponsor.Github,
		response.Sponsor.Paypal,
		response.Sponsor.Paypal,
		response.UserInfo.Username,
		response.UserInfo.Points,
		response.UserInfo.Locale,
		response.UserInfo.Type,
		response.UserInfo.Premium,
		response.UserInfo.Expiration,
		response.Config.Version,
		strings.Replace(response.Config.Token, response.Config.Token[len(response.Config.Token)-48:], "*****", 1),
		response.Config.Host,
		response.Config.Port,
		response.Config.NumOfWorkers,
		response.Config.RefreshEverySeconds,
		response.Config.RetainRDTorrentName,
		response.Config.RetainFolderNameExtension,
		response.Config.CanRepair,
		response.Config.DeleteRarFiles,
		response.Config.RealDebridTimeout,
		response.Config.UseDownloadCache,
		response.Config.RateLimitSleepSeconds,
		response.Config.RetriesUntilFailed,
		strings.Join(response.Config.PreferredHosts, ", "),
		response.Config.NetworkBufferSize,
		response.Config.ServeFromRclone,
		response.Config.VerifyDownloadLink,
		response.Config.ForceIPv6,
		response.Config.OnLibraryUpdate,
	)

	fmt.Fprint(resp, out)
}

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
}