Merge branch 'beta'

- Per-file repair instead of per-torrent
- Fix issues with LoadLocation
- Fix other minor bug fixes woth torbox

.dockerignore

@@ -10,3 +10,4 @@ torrents.json
 **/dist/
 *.json
 .ven/**
+docs/**

.github/workflows/deploy-docs.yml

@@ -3,7 +3,6 @@ on:
   push:
     branches:
       - main
-      - beta
 permissions:
   contents: write
 jobs:

.github/workflows/goreleaser.yml

@@ -20,7 +20,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v4
         with:
-          go-version: '1.22'
+          go-version: '1.24'
 
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v5

Dockerfile

@@ -1,5 +1,5 @@
 # Stage 1: Build binaries
-FROM --platform=$BUILDPLATFORM golang:1.23-alpine as builder
+FROM --platform=$BUILDPLATFORM golang:1.24-alpine as builder
 
 ARG TARGETOS
 ARG TARGETARCH
@@ -57,10 +57,10 @@ COPY --from=dirsetup --chown=nonroot:nonroot /app /app
 
 # Metadata
 ENV LOG_PATH=/app/logs
-EXPOSE 8181 8282
+EXPOSE 8282
 VOLUME ["/app"]
 USER nonroot:nonroot
 
-HEALTHCHECK CMD ["/usr/bin/healthcheck"]
+HEALTHCHECK --interval=3s --retries=10 CMD ["/usr/bin/healthcheck", "--config", "/app"]
 
 CMD ["/usr/bin/decypharr", "--config", "/app"]

README.md

@@ -1,12 +1,12 @@
-# DecyphArr
+# Decypharr
 
 ![ui](docs/docs/images/main.png)
 
-**DecyphArr** is an implementation of QbitTorrent with **Multiple Debrid service support**, written in Go.
+**Decypharr** is an implementation of QbitTorrent with **Multiple Debrid service support**, written in Go.
 
-## What is DecyphArr?
+## What is Decypharr?
 
-DecyphArr combines the power of QBittorrent with popular Debrid services to enhance your media management. It provides a familiar interface for Sonarr, Radarr, and other \*Arr applications while leveraging the capabilities of Debrid providers.
+Decypharr combines the power of QBittorrent with popular Debrid services to enhance your media management. It provides a familiar interface for Sonarr, Radarr, and other \*Arr applications while leveraging the capabilities of Debrid providers.
 
 ## Features
 
@@ -49,7 +49,7 @@ services:
 
 ## Documentation
 
-For complete documentation, please visit our [Documentation](https://sirrobot01.github.io/debrid-blackhole/).
+For complete documentation, please visit our [Documentation](https://sirrobot01.github.io/decypharr/).
 
 The documentation includes:
 
@@ -67,24 +67,18 @@ The documentation includes:
   "debrids": [
     {
       "name": "realdebrid",
-      "host": "https://api.real-debrid.com/rest/1.0",
       "api_key": "your_api_key_here",
       "folder": "/mnt/remote/realdebrid/__all__/",
       "use_webdav": true
     }
   ],
   "qbittorrent": {
-    "port": "8282",
     "download_folder": "/mnt/symlinks/",
     "categories": ["sonarr", "radarr"]
   },
-  "repair": {
-    "enabled": false,
-    "interval": "12h",
-    "run_on_start": false
-  },
   "use_auth": false,
-  "log_level": "info"
+  "log_level": "info",
+  "port": "8282"
 }
 ```
 

cmd/decypharr/main.go

@@ -12,11 +12,12 @@ import (
 	"github.com/sirrobot01/decypharr/pkg/web"
 	"github.com/sirrobot01/decypharr/pkg/webdav"
 	"github.com/sirrobot01/decypharr/pkg/worker"
+	"net/http"
 	"os"
+	"runtime"
 	"runtime/debug"
 	"strconv"
 	"sync"
-	"syscall"
 )
 
 func Start(ctx context.Context) error {
@@ -26,32 +27,92 @@ func Start(ctx context.Context) error {
 		if err != nil {
 			return fmt.Errorf("invalid UMASK value: %s", umaskStr)
 		}
-		// Set umask
-		syscall.Umask(int(umask))
+		SetUmask(int(umask))
 	}
 
-	cfg := config.Get()
+	restartCh := make(chan struct{}, 1)
+	web.SetRestartFunc(func() {
+		select {
+		case restartCh <- struct{}{}:
+		default:
+		}
+	})
+
+	svcCtx, cancelSvc := context.WithCancel(ctx)
+	defer cancelSvc()
+
+	for {
+		cfg := config.Get()
+		_log := logger.Default()
+
+		// ascii banner
+		fmt.Printf(`
++-------------------------------------------------------+
+|                                                       |
+|  ╔╦╗╔═╗╔═╗╦ ╦╔═╗╦ ╦╔═╗╦═╗╦═╗                          |
+|   ║║║╣ ║  └┬┘╠═╝╠═╣╠═╣╠╦╝╠╦╝ (%s)        |
+|  ═╩╝╚═╝╚═╝ ┴ ╩  ╩ ╩╩ ╩╩╚═╩╚═                          |
+|                                                       |
++-------------------------------------------------------+
+|  Log Level: %s                                        |
++-------------------------------------------------------+
+`, version.GetInfo(), cfg.LogLevel)
+
+		// Initialize services
+		qb := qbit.New()
+		wd := webdav.New()
+
+		ui := web.New(qb).Routes()
+		webdavRoutes := wd.Routes()
+		qbitRoutes := qb.Routes()
+
+		// Register routes
+		handlers := map[string]http.Handler{
+			"/":       ui,
+			"/api/v2": qbitRoutes,
+			"/webdav": webdavRoutes,
+		}
+		srv := server.New(handlers)
+
+		done := make(chan struct{})
+		go func(ctx context.Context) {
+			if err := startServices(ctx, wd, srv); err != nil {
+				_log.Error().Err(err).Msg("Error starting services")
+				cancelSvc()
+			}
+			close(done)
+		}(svcCtx)
+
+		select {
+		case <-ctx.Done():
+			// graceful shutdown
+			cancelSvc() // propagate to services
+			<-done      // wait for them to finish
+			return nil
+
+		case <-restartCh:
+			cancelSvc() // tell existing services to shut down
+			_log.Info().Msg("Restarting Decypharr...")
+			<-done // wait for them to finish
+			qb.Reset()
+			service.Reset()
+
+			// rebuild svcCtx off the original parent
+			svcCtx, cancelSvc = context.WithCancel(ctx)
+			runtime.GC()
+
+			config.Reload()
+			service.Reset()
+			// loop will restart services automatically
+		}
+	}
+}
+
+func startServices(ctx context.Context, wd *webdav.WebDav, srv *server.Server) error {
 	var wg sync.WaitGroup
 	errChan := make(chan error)
 
-	_log := logger.GetDefaultLogger()
-
-	_log.Info().Msgf("Starting Decypher (%s)", version.GetInfo().String())
-	_log.Info().Msgf("Default Log Level: %s", cfg.LogLevel)
-
-	svc := service.New()
-	_qbit := qbit.New()
-	srv := server.New()
-	_webdav := webdav.New()
-
-	ui := web.New(_qbit).Routes()
-	webdavRoutes := _webdav.Routes()
-	qbitRoutes := _qbit.Routes()
-
-	// Register routes
-	srv.Mount("/", ui)
-	srv.Mount("/api/v2", qbitRoutes)
-	srv.Mount("/webdav", webdavRoutes)
+	_log := logger.Default()
 
 	safeGo := func(f func() error) {
 		wg.Add(1)
@@ -77,7 +138,7 @@ func Start(ctx context.Context) error {
 	}
 
 	safeGo(func() error {
-		return _webdav.Start(ctx)
+		return wd.Start(ctx)
 	})
 
 	safeGo(func() error {
@@ -88,13 +149,23 @@ func Start(ctx context.Context) error {
 		return worker.Start(ctx)
 	})
 
-	if cfg.Repair.Enabled {
+	safeGo(func() error {
+		arr := service.GetService().Arr
+		if arr == nil {
+			return nil
+		}
+		return arr.StartSchedule(ctx)
+	})
+
+	if cfg := config.Get(); cfg.Repair.Enabled {
 		safeGo(func() error {
-			err := svc.Repair.Start(ctx)
-			if err != nil {
-				_log.Error().Err(err).Msg("Error during repair")
+			r := service.GetService().Repair
+			if r != nil {
+				if err := r.Start(ctx); err != nil {
+					_log.Error().Err(err).Msg("repair failed")
+				}
 			}
-			return nil // Not propagating repair errors to terminate the app
+			return nil
 		})
 	}
 
@@ -103,11 +174,17 @@ func Start(ctx context.Context) error {
 		close(errChan)
 	}()
 
-	// Wait for context cancellation or completion or error
-	select {
-	case err := <-errChan:
-		return err
-	case <-ctx.Done():
-		return ctx.Err()
-	}
+	go func() {
+		for err := range errChan {
+			if err != nil {
+				_log.Error().Err(err).Msg("Service error detected")
+				// Don't shut down the whole app
+			}
+		}
+	}()
+
+	// Wait for context cancellation
+	<-ctx.Done()
+	_log.Debug().Msg("Services context cancelled")
+	return nil
 }

cmd/decypharr/umask_unix.go

@@ -0,0 +1,9 @@
+//go:build !windows
+
+package decypharr
+
+import "syscall"
+
+func SetUmask(umask int) {
+	syscall.Umask(umask)
+}

cmd/decypharr/umask_win.go

@@ -0,0 +1,8 @@
+//go:build windows
+// +build windows
+
+package decypharr
+
+func SetUmask(umask int) {
+	// No-op on Windows
+}

cmd/healthcheck/main.go

@@ -2,21 +2,148 @@ package main
 
 import (
 	"cmp"
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/config"
 	"net/http"
 	"os"
+	"strings"
+	"time"
 )
 
+// HealthStatus represents the status of various components
+type HealthStatus struct {
+	QbitAPI       bool `json:"qbit_api"`
+	WebUI         bool `json:"web_ui"`
+	WebDAVService bool `json:"webdav_service"`
+	OverallStatus bool `json:"overall_status"`
+}
+
 func main() {
-	port := cmp.Or(os.Getenv("QBIT_PORT"), "8282")
-	resp, err := http.Get("http://localhost:" + port + "/api/v2/app/version")
-	if err != nil {
+	var configPath string
+	flag.StringVar(&configPath, "config", "/data", "path to the data folder")
+	flag.Parse()
+	config.SetConfigPath(configPath)
+	cfg := config.Get()
+	// Get port from environment variable or use default
+	port := getEnvOrDefault("QBIT_PORT", cfg.Port)
+	webdavPath := ""
+	for _, debrid := range cfg.Debrids {
+		if debrid.UseWebDav {
+			webdavPath = debrid.Name
+		}
+	}
+
+	// Initialize status
+	status := HealthStatus{
+		QbitAPI:       false,
+		WebUI:         false,
+		WebDAVService: false,
+		OverallStatus: false,
+	}
+
+	// Create a context with timeout for all HTTP requests
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	baseUrl := cmp.Or(cfg.URLBase, "/")
+	if !strings.HasPrefix(baseUrl, "/") {
+		baseUrl = "/" + baseUrl
+	}
+
+	// Check qBittorrent API
+	if checkQbitAPI(ctx, baseUrl, port) {
+		status.QbitAPI = true
+	}
+
+	// Check Web UI
+	if checkWebUI(ctx, baseUrl, port) {
+		status.WebUI = true
+	}
+
+	// Check WebDAV if enabled
+	if webdavPath != "" {
+		if checkWebDAV(ctx, baseUrl, port, webdavPath) {
+			status.WebDAVService = true
+		}
+	} else {
+		// If WebDAV is not enabled, consider it healthy
+		status.WebDAVService = true
+	}
+
+	// Determine overall status
+	// Consider the application healthy if core services are running
+	status.OverallStatus = status.QbitAPI && status.WebUI
+	if webdavPath != "" {
+		status.OverallStatus = status.OverallStatus && status.WebDAVService
+	}
+
+	// Optional: output health status as JSON for logging
+	if os.Getenv("DEBUG") == "true" {
+		statusJSON, _ := json.MarshalIndent(status, "", "  ")
+		fmt.Println(string(statusJSON))
+	}
+
+	// Exit with appropriate code
+	if status.OverallStatus {
+		os.Exit(0)
+	} else {
 		os.Exit(1)
 	}
+}
+
+func getEnvOrDefault(key, defaultValue string) string {
+	if value, exists := os.LookupEnv(key); exists {
+		return value
+	}
+	return defaultValue
+}
+
+func checkQbitAPI(ctx context.Context, baseUrl, port string) bool {
+	url := fmt.Sprintf("http://localhost:%s%sapi/v2/app/version", port, baseUrl)
+	req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
+	if err != nil {
+		return false
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode != http.StatusOK {
-		os.Exit(1)
+	return resp.StatusCode == http.StatusOK
+}
+
+func checkWebUI(ctx context.Context, baseUrl, port string) bool {
+	req, err := http.NewRequestWithContext(ctx, "GET", fmt.Sprintf("http://localhost:%s%s", port, baseUrl), nil)
+	if err != nil {
+		return false
 	}
 
-	os.Exit(0)
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode == http.StatusOK
+}
+
+func checkWebDAV(ctx context.Context, baseUrl, port, path string) bool {
+	url := fmt.Sprintf("http://localhost:%s%swebdav/%s", port, baseUrl, path)
+	req, err := http.NewRequestWithContext(ctx, "PROPFIND", url, nil)
+	if err != nil {
+		return false
+	}
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return false
+	}
+	defer resp.Body.Close()
+
+	return resp.StatusCode == 207 || resp.StatusCode == http.StatusOK
 }

docs/docs/changelog.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 1.0.0
+
+- Add WebDAV support for debrid providers
+- Some refactoring and code cleanup
+- Fixes
+    - Fix Alldebrid not downloading torrents
+    - Fix Alldebrid not downloading uncached torrents
+    - Fix uncached torrents not being downloaded for RealDebrid
+- Add support for multiple download API keys for debrid providers
+- Add support for editable config.json via the UI
+- Fix downloading timeout
+- Fix UMASK for Windows
+- Retries 50x(except 503) errors for RD
+
+
 ## 0.5.0
 
 - A more refined repair worker (with more control)

docs/docs/configuration/arrs.md

@@ -1,6 +1,6 @@
 # Arr Applications Configuration
 
-DecyphArr can integrate directly with Sonarr, Radarr, and other Arr applications. This section explains how to configure the Arr integration in your `config.json` file.
+Decypharr can integrate directly with Sonarr, Radarr, and other Arr applications. This section explains how to configure the Arr integration in your `config.json` file.
 
 ## Basic Configuration
 
@@ -34,12 +34,14 @@ Each Arr application supports the following options:
 - `host`: The host URL of the Arr application, including protocol and port
 - `token`: The API token/key of the Arr application
 - `cleanup`: Whether to clean up the Arr queue (removes completed downloads). This is only useful for Sonarr.
+- `skip_repair`: Automated repair will be skipped for this *arr.
+- `download_uncached`: Whether to download uncached torrents (defaults to debrid/manual setting)
 
 ### Finding Your API Key
 #### Sonarr/Radarr/Lidarr
 
 1. Go to Sonarr > Settings > General
-2. Look for "API Key" in the "General" section
+2. Look for "API Key" in the "Security" section
 3. Copy the API key
 
 ### Multiple Arr Applications

docs/docs/configuration/debrid.md

@@ -1,7 +1,7 @@
 
 # Debrid Providers Configuration
 
-DecyphArr supports multiple Debrid providers. This section explains how to configure each provider in your `config.json` file.
+Decypharr supports multiple Debrid providers. This section explains how to configure each provider in your `config.json` file.
 
 ## Basic Configuration
 
@@ -11,13 +11,11 @@ Each Debrid provider is configured in the `debrids` array:
 "debrids": [
   {
     "name": "realdebrid",
-    "host": "https://api.real-debrid.com/rest/1.0",
     "api_key": "your-api-key",
-    "folder": "/mnt/remote/realdebrid/__all__/"
+    "folder": "/mnt/remote/realdebrid/__all__/",
   },
   {
     "name": "alldebrid",
-    "host": "https://api.alldebrid.com/v4",
     "api_key": "your-api-key",
     "folder": "/mnt/remote/alldebrid/downloads/"
   }
@@ -29,7 +27,7 @@ Each Debrid provider is configured in the `debrids` array:
 Each Debrid provider accepts the following configuration options:
 
 
-#### Basic Options
+#### Basic(Required) Options
 
 - `name`: The name of the Debrid provider (realdebrid, alldebrid, debridlink, torbox)
 - `host`: The API endpoint of the Debrid provider
@@ -38,26 +36,44 @@ Each Debrid provider accepts the following configuration options:
 
 #### Advanced Options
 
-- `download_api_keys`: Array of API keys used specifically for downloading torrents (defaults to the same as api_key)
 - `rate_limit`: Rate limit for API requests (null by default)
 - `download_uncached`: Whether to download uncached torrents (disabled by default)
 - `check_cached`: Whether to check if torrents are cached (disabled by default)
 - `use_webdav`: Whether to create a WebDAV server for this Debrid provider (disabled by default)
+- `proxy`: Proxy URL for the Debrid provider (optional)
 
+#### WebDAV and Rclone Options
+- `torrents_refresh_interval`: Interval for refreshing torrent data (e.g., `15s`, `1m`, `1h`).
+- `download_links_refresh_interval`: Interval for refreshing download links (e.g., `40m`, `1h`).
+- `workers`: Number of concurrent workers for processing requests.
+- `serve_from_rclone`: Whether to serve files directly from Rclone (disabled by default)
+- `add_samples`: Whether to add sample files when adding torrents to debrid (disabled by default)
+- `folder_naming`: Naming convention for folders:
+    - `original_no_ext`: Original file name without extension
+    - `original`: Original file name with extension
+    - `filename`: Torrent filename
+    - `filename_no_ext`: Torrent filename without extension
+    - `id`: Torrent ID
+    - `hash`: Torrent hash
+- `auto_expire_links_after`: Time after which download links will expire (e.g., `3d`, `1w`).
+- `rc_url`, `rc_user`, `rc_pass`, `rc_refresh_dirs`: Rclone RC configuration for VFS refreshes
+- `directories`: A map of virtual folders to serve via the webDAV server. The key is the virtual folder name, and the values are map of filters and their value
 
-### Using Multiple API Keys
-For services that support it, you can provide multiple download API keys for better load balancing:
-
+#### Example of `directories` configuration
 ```json
-{
-  "name": "realdebrid",
-  "host": "https://api.real-debrid.com/rest/1.0",
-  "api_key": "key1",
-  "download_api_keys": ["key1", "key2", "key3"],
-  "folder": "/mnt/remote/realdebrid/__all__/"
-}
-
-
+    "directories": {
+        "Newly Added": {
+          "filters": {
+            "exclude": "9-1-1",
+            "last_added": "20h"
+          }
+        },
+        "Spiderman Collection": {
+          "filters": {
+            "regex": "(?i)spider[-\\s]?man(\\s+collection|\\s+\\d|\\s+trilogy|\\s+complete|\\s+ultimate|\\s+box\\s+set|:?\\s+homecoming|:?\\s+far\\s+from\\s+home|:?\\s+no\\s+way\\s+home)"
+          }
+        }
+      }
 ```
 
 ### Example Configuration
@@ -67,12 +83,10 @@ For services that support it, you can provide multiple download API keys for bet
 ```json
 {
   "name": "realdebrid",
-  "host": "https://api.real-debrid.com/rest/1.0",
   "api_key": "your-api-key",
   "folder": "/mnt/remote/realdebrid/__all__/",
   "rate_limit": null,
   "download_uncached": false,
-  "check_cached": true,
   "use_webdav": true
 }
 ```
@@ -82,12 +96,10 @@ For services that support it, you can provide multiple download API keys for bet
 ```json
 {
   "name": "alldebrid",
-  "host": "https://api.alldebrid.com/v4",
   "api_key": "your-api-key",
   "folder": "/mnt/remote/alldebrid/torrents/",
   "rate_limit": null,
   "download_uncached": false,
-  "check_cached": true,
   "use_webdav": true
 }
 ```
@@ -97,12 +109,10 @@ For services that support it, you can provide multiple download API keys for bet
 ```json
 {
   "name": "debridlink",
-  "host": "https://debrid-link.com/api/v2",
   "api_key": "your-api-key",
   "folder": "/mnt/remote/debridlink/torrents/",
   "rate_limit": null,
   "download_uncached": false,
-  "check_cached": true,
   "use_webdav": true
 }
 ```
@@ -112,12 +122,10 @@ For services that support it, you can provide multiple download API keys for bet
 ```json
 {
   "name": "torbox",
-  "host": "https://api.torbox.com/v1",
   "api_key": "your-api-key",
   "folder": "/mnt/remote/torbox/torrents/",
   "rate_limit": null,
   "download_uncached": false,
-  "check_cached": true,
   "use_webdav": true
 }
 ```

docs/docs/configuration/general.md

@@ -1,6 +1,6 @@
 # General Configuration
 
-This section covers the basic configuration options for DecyphArr that apply to the entire application.
+This section covers the basic configuration options for Decypharr that apply to the entire application.
 
 ## Basic Settings
 
@@ -9,11 +9,13 @@ Here are the fundamental configuration options:
 ```json
 {
   "use_auth": false,
+  "port": 8282,
   "log_level": "info",
   "discord_webhook_url": "",
   "min_file_size": 0,
   "max_file_size": 0,
-  "allowed_file_types": [".mp4", ".mkv", ".avi", ...]
+  "allowed_file_types": [".mp4", ".mkv", ".avi", ...],
+  
 }
 ```
 
@@ -28,6 +30,16 @@ The `log_level` setting determines how verbose the application logs will be:
 - `error`: Error messages only
 - `trace`: Very detailed information, including all requests and responses
 
+#### Port
+
+The `port` setting specifies the port on which Decypharr will run. The default is `8282`. You can change this to any available port on your server.
+
+Ensure this port:
+
+- Is not used by other applications
+- Is accessible to your Arr applications
+- Is properly exposed if using Docker (see the Docker Compose example in the Installation guide)
+
 
 #### Authentication
 The `use_auth` option enables basic authentication for the UI:
@@ -36,7 +48,7 @@ The `use_auth` option enables basic authentication for the UI:
 "use_auth": true
 ```
 
-When enabled, you'll need to provide a username and password to access the DecyphArr interface.
+When enabled, you'll need to provide a username and password to access the Decypharr interface.
 
 
 #### File Size Limits
@@ -48,7 +60,7 @@ You can set minimum and maximum file size limits for torrents:
 ```
 
 #### Allowed File Types
-You can restrict the types of files that DecyphArr will process by specifying allowed file extensions. This is useful for filtering out unwanted file types.
+You can restrict the types of files that Decypharr will process by specifying allowed file extensions. This is useful for filtering out unwanted file types.
 
 ```json
 "allowed_file_types": [

docs/docs/configuration/index.md

@@ -1,6 +1,6 @@
 # Configuration Overview
 
-DecyphArr uses a JSON configuration file to manage its settings. This file should be named `config.json` and placed in your configured directory.
+Decypharr uses a JSON configuration file to manage its settings. This file should be named `config.json` and placed in your configured directory.
 
 ## Basic Configuration
 
@@ -11,9 +11,9 @@ Here's a minimal configuration to get started:
   "debrids": [
     {
       "name": "realdebrid",
-      "host": "https://api.real-debrid.com/rest/1.0",
       "api_key": "realdebrid_key",
-      "folder": "/mnt/remote/realdebrid/__all__/"
+      "folder": "/mnt/remote/realdebrid/__all__/",
+      "use_webdav": true
     }
   ],
   "qbittorrent": {
@@ -33,7 +33,7 @@ Here's a minimal configuration to get started:
 
 ### Configuration Sections
 
-DecyphArr's configuration is divided into several sections:
+Decypharr's configuration is divided into several sections:
 
 - [General Configuration](general.md) - Basic settings like logging and authentication
 - [Debrid Providers](debrid.md) - Configure one or more Debrid services

docs/docs/configuration/qbittorrent.md

@@ -1,6 +1,6 @@
 # qBittorrent Configuration
 
-DecyphArr emulates a qBittorrent instance to integrate with Arr applications. This section explains how to configure the qBittorrent settings in your `config.json` file.
+Decypharr emulates a qBittorrent instance to integrate with Arr applications. This section explains how to configure the qBittorrent settings in your `config.json` file.
 
 ## Basic Configuration
 
@@ -8,7 +8,6 @@ The qBittorrent functionality is configured under the `qbittorrent` key:
 
 ```json
 "qbittorrent": {
-  "port": "8282",
   "download_folder": "/mnt/symlinks/",
   "categories": ["sonarr", "radarr", "lidarr"],
   "refresh_interval": 5
@@ -16,15 +15,16 @@ The qBittorrent functionality is configured under the `qbittorrent` key:
 ```
 
 ### Configuration Options
-#### Essential Settings
+#### Required Settings
 
-- `port`: The port on which the qBittorrent API will listen (default: 8282)
 - `download_folder`: The folder where symlinks or downloaded files will be placed
 - `categories`: An array of categories to organize downloads (usually matches your Arr applications)
 
 #### Advanced Settings
 
 - `refresh_interval`: How often (in seconds) to refresh the Arrs Monitored Downloads (default: 5)
+- `max_downloads`: The maximum number of concurrent downloads. This is only for downloading real files(Not symlinks). If you set this to 0, it will download all files at once. This is not recommended for most users.(default: 5)
+- `skip_pre_cache`: This option disables the process of pre-caching files. This caches a small portion of the file to speed up your *arrs import process. 
 
 #### Categories
 Categories help organize your downloads and match them to specific Arr applications. Typically, you'll want to configure categories that match your Sonarr, Radarr, or other Arr applications:
@@ -33,11 +33,11 @@ Categories help organize your downloads and match them to specific Arr applicati
 "categories": ["sonarr", "radarr", "lidarr", "readarr"]
 ```
 
-When setting up your Arr applications to connect to DecyphArr, you'll specify these same category names.
+When setting up your Arr applications to connect to Decypharr, you'll specify these same category names.
 
 #### Download Folder
 
-The `download_folder` setting specifies where DecyphArr will place downloaded files or create symlinks:
+The `download_folder` setting specifies where Decypharr will place downloaded files or create symlinks:
 
 ```json
 "download_folder": "/mnt/symlinks/"
@@ -45,26 +45,13 @@ The `download_folder` setting specifies where DecyphArr will place downloaded fi
 
 This folder should be:
 
-- Accessible to DecyphArr
+- Accessible to Decypharr
 - Accessible to your Arr applications
 - Have sufficient space if downloading files locally
 
 
-#### Port Configuration
-The `port` setting determines which port the qBittorrent API will listen on:
-
-```json
-"port": "8282"
-```
-
-Ensure this port:
-
-- Is not used by other applications
-- Is accessible to your Arr applications
-- Is properly exposed if using Docker (see the Docker Compose example in the Installation guide)
-
 #### Refresh Interval
-The refresh_interval setting controls how often DecyphArr checks for updates from your Arr applications:
+The refresh_interval setting controls how often Decypharr checks for updates from your Arr applications:
 
 ```json
 "refresh_interval": 5

docs/docs/extras/config.full.json

@@ -2,14 +2,12 @@
   "debrids": [
     {
       "name": "realdebrid",
-      "host": "https://api.real-debrid.com/rest/1.0",
       "api_key": "realdebrid_key",
       "folder": "/mnt/remote/realdebrid/__all__/",
       "download_api_keys": [],
       "proxy": "",
       "rate_limit": "250/minute",
       "download_uncached": false,
-      "check_cached": false,
       "use_webdav": true,
       "torrents_refresh_interval": "15s",
       "folder_naming": "original_no_ext",
@@ -20,30 +18,24 @@
     },
     {
       "name": "torbox",
-      "host": "https://api.torbox.app/v1",
       "api_key": "torbox_api_key",
       "folder": "/mnt/remote/torbox/torrents/",
       "rate_limit": "250/minute",
       "download_uncached": false,
-      "check_cached": true
     },
     {
       "name": "debridlink",
-      "host": "https://debrid-link.com/api/v2",
       "api_key": "debridlink_key",
       "folder": "/mnt/remote/debridlink/torrents/",
       "rate_limit": "250/minute",
       "download_uncached": false,
-      "check_cached": false
     },
     {
       "name": "alldebrid",
-      "host": "http://api.alldebrid.com/v4.1",
       "api_key": "alldebrid_key",
       "folder": "/mnt/remote/alldebrid/magnet/",
       "rate_limit": "600/minute",
       "download_uncached": false,
-      "check_cached": false
     }
   ],
   "max_cache_size": 1000,
@@ -57,7 +49,7 @@
   "arrs": [
     {
       "name": "sonarr",
-      "host": "http://radarr:8989",
+      "host": "http://sonarr:8989",
       "token": "arr_key",
       "cleanup": true,
       "skip_repair": true,
@@ -72,7 +64,7 @@
     },
     {
       "name": "lidarr",
-      "host": "http://lidarr:7878",
+      "host": "http://lidarr:8686",
       "token": "arr_key",
       "cleanup": false,
       "skip_repair": true,

docs/docs/features/index.md

@@ -1,12 +1,12 @@
 # Features Overview
 
-DecyphArr extends the functionality of qBittorrent by integrating with Debrid services, providing several powerful features that enhance your media management experience.
+Decypharr extends the functionality of qBittorrent by integrating with Debrid services, providing several powerful features that enhance your media management experience.
 
 ## Core Features
 
 ### Mock qBittorrent API
 
-DecyphArr implements a complete qBittorrent-compatible API that can be used with Sonarr, Radarr, Lidarr, and other Arr applications. This allows you to:
+Decypharr implements a complete qBittorrent-compatible API that can be used with Sonarr, Radarr, Lidarr, and other Arr applications. This allows you to:
 
 - Seamlessly integrate with your existing Arr setup
 - Use familiar interfaces to manage your downloads
@@ -14,7 +14,7 @@ DecyphArr implements a complete qBittorrent-compatible API that can be used with
 
 ### Comprehensive UI
 
-The DecyphArr user interface provides:
+The Decypharr user interface provides:
 
 - Torrent management capabilities
 - Status monitoring
@@ -23,14 +23,14 @@ The DecyphArr user interface provides:
 
 ## Advanced Features
 
-DecyphArr includes several advanced features that extend its capabilities:
+Decypharr includes several advanced features that extend its capabilities:
 
 - [Repair Worker](repair-worker.md): Identifies and fixes issues with your media files
 - [WebDAV Server](webdav.md): Provides direct access to your Debrid files
 
 ## Supported Debrid Providers
 
-DecyphArr supports multiple Debrid providers:
+Decypharr supports multiple Debrid providers:
 
 - Real Debrid
 - Torbox

docs/docs/features/repair-worker.md

@@ -30,7 +30,7 @@ To enable and configure the Repair Worker, add the following to your `config.jso
 
 - `enabled`: Set to `true` to enable the Repair Worker.
 - `interval`: The time interval for the Repair Worker to run (e.g., `12h`, `1d`).
-- `run_on_start`: If set to `true`, the Repair Worker will run immediately after DecyphArr starts.
+- `run_on_start`: If set to `true`, the Repair Worker will run immediately after Decypharr starts.
 - `use_webdav`: If set to `true`, the Repair Worker will use WebDAV for file operations.
 - `zurg_url`: The URL for the Zurg service (if using).
 - `auto_process`: If set to `true`, the Repair Worker will automatically process files that it finds issues with.

docs/docs/features/webdav.md

@@ -1,14 +1,15 @@
 # WebDAV Server
 
-DecyphArr includes a built-in WebDAV server that provides direct access to your Debrid files, making them easily accessible to media players and other applications.
+Decypharr includes a built-in WebDAV server that provides direct access to your Debrid files, making them easily accessible to media players and other applications.
+
 
 ## Overview
 
-While most Debrid providers have their own WebDAV servers, DecyphArr's implementation offers faster access and additional features. The WebDAV server listens on port `8080` by default.
+While most Debrid providers have their own WebDAV servers, Decypharr's implementation offers faster access and additional features.
 
 ## Accessing the WebDAV Server
 
-- URL: `http://localhost:8282/webdav` or `http://<your-server-ip>:8080/webdav`
+- URL: `http://localhost:8282/webdav` or `http://<your-server-ip>:8282/webdav`
 
 ## Configuration
 
@@ -22,7 +23,16 @@ You can configure WebDAV settings either globally or per-Debrid provider in your
   "auto_expire_links_after": "3d",
   "rc_url": "http://localhost:5572",
   "rc_user": "username",
-  "rc_pass": "password"
+  "rc_pass": "password",
+  "serve_from_rclone": false,
+  "directories": {
+      "Newly Added": {
+        "filters": {
+          "exclude": "9-1-1",
+          "last_added": "20h"
+        }
+      }
+  }
 }
 ```
 
@@ -39,13 +49,15 @@ You can configure WebDAV settings either globally or per-Debrid provider in your
   - `id`: Torrent ID
 - `auto_expire_links_after`: Time after which download links will expire (e.g., `3d`, `1w`).
 - `rc_url`, `rc_user`, `rc_pass`: Rclone RC configuration for VFS refreshes
+- `directories`: A map of virtual folders to serve via the WebDAV server. The key is the virtual folder name, and the values are a map of filters and their values.
+- `serve_from_rclone`: Whether to serve files directly from Rclone (disabled by default).
 
 ### Using with Media Players
 The WebDAV server works well with media players like:
 
 - Infuse
 - VidHub
-- Plex (via mounting)
+- Plex, Emby, Jellyfin (with rclone, Check [this guide](../guides/rclone.md))
 - Kodi
 
 ### Mounting with Rclone
@@ -54,7 +66,7 @@ You can mount the WebDAV server locally using Rclone. Example configuration:
 ```conf
 [decypharr]
 type = webdav
-url = http://localhost:8080/webdav/realdebrid
+url = http://localhost:8282/webdav/realdebrid
 vendor = other
 ```
 For a complete Rclone configuration example, see our [sample rclone.conf](../extras/rclone.conf).

docs/docs/guides/index.md

@@ -0,0 +1,4 @@
+# Guides for setting up Decypharr
+
+
+- [Setting up with Rclone](rclone.md)

docs/docs/guides/rclone.md

@@ -0,0 +1,142 @@
+# Setting up Decypharr with Rclone
+
+This guide will help you set up Decypharr with Rclone, allowing you to use your Debrid providers as a remote storage solution.
+
+#### Rclone
+Make sure you have Rclone installed and configured on your system. You can follow the [Rclone installation guide](https://rclone.org/install/) for instructions.
+
+It's recommended to use docker version of Rclone, as it provides a consistent environment across different platforms. 
+
+
+### Steps
+
+We'll be using docker compose to set up Rclone and Decypharr together.
+
+#### Note
+This guide assumes you have a basic understanding of Docker and Docker Compose. If you're new to Docker, consider checking out the [Docker documentation](https://docs.docker.com/get-started/) for more information.
+
+Also, ensure you have Docker and Docker Compose installed on your system. You can find installation instructions in the [Docker documentation](https://docs.docker.com/get-docker/) and [Docker Compose documentation](https://docs.docker.com/compose/install/).
+
+
+Create a directory for your Decypharr and Rclone setup:
+```bash
+mkdir -p /opt/decypharr
+mkdir -p /opt/rclone
+mkdir -p /mnt/remote/realdebrid
+
+# Set permissions
+chown -R $USER:$USER /opt/decypharr
+chown -R $USER:$USER /opt/rclone
+chown -R $USER:$USER /mnt/remote/realdebrid
+```
+
+Create a `rclone.conf` file in `/opt/rclone/` with your Rclone configuration. 
+
+```conf
+[decypharr]
+type = webdav
+url = https://your-ip-or-domain:8282/webdav/realdebrid
+vendor = other
+pacer_min_sleep = 0
+```
+
+Create a `config.json` file in `/opt/decypharr/` with your Decypharr configuration. 
+
+```json
+{
+  "debrids": [
+    {
+      "name": "realdebrid",
+      "api_key": "realdebrid_key",
+      "folder": "/mnt/remote/realdebrid/__all__/",
+      "rate_limit": "250/minute",
+      "use_webdav": true,
+      "rc_url": "http://your-ip-address:5572" // Rclone RC URL
+    }
+  ],
+  "qbittorrent": {
+    "download_folder": "data/media/symlinks/",
+    "refresh_interval": 10
+  }
+}
+
+```
+
+Create a `docker-compose.yml` file with the following content:
+
+```yaml
+services:
+  decypharr:
+    image: cy01/blackhole:latest
+    container_name: decypharr
+    user: "1000:1000"
+    volumes:
+      - /mnt/:/mnt
+      - /opt/decypharr/:/app
+    environment:
+      - PUID=1000
+      - PGID=1000
+      - UMASK=002
+    ports:
+      - "8282:8282/tcp"
+    restart: unless-stopped
+  
+  rclone:
+    image: rclone/rclone:latest
+    container_name: rclone
+    restart: unless-stopped
+    environment:
+      TZ: UTC
+      PUID: 1000
+      PGID: 1000
+    ports:
+     - 5572:5572
+    volumes:
+      - /mnt/remote/realdebrid:/data:rshared
+      - /opt/rclone/rclone.conf:/config/rclone/rclone.conf
+      - /mnt:/mnt
+    cap_add:
+      - SYS_ADMIN
+    security_opt:
+      - apparmor:unconfined
+    devices:
+      - /dev/fuse:/dev/fuse:rwm
+    depends_on:
+      decypharr:
+        condition: service_healthy
+        restart: true
+    command: "mount decypharr: /data --allow-non-empty --allow-other --uid=1000 --gid=1000 --umask=002 --dir-cache-time 10s --rc --rc-addr :5572 --rc-no-auth "
+```
+
+Start the containers:
+```bash
+docker-compose up -d
+```
+
+Access the Decypharr web interface at `http://your-ip-address:8282` and configure your settings as needed.
+
+- Access your webdav server at `http://your-ip-address:8282/webdav` to see your files.
+- You should be able to see your files in the `/mnt/remote/realdebrid/__all__/` directory.
+- You can now use your Debrid provider as a remote storage solution with Rclone and Decypharr.
+- You can also use the Rclone mount command to mount your Debrid provider locally. For example:
+
+
+### Notes
+
+- Make sure to replace `your-ip-address` with the actual IP address of your server.
+- You can use multiple Debrid providers by adding them to the `debrids` array in the `config.json` file.
+
+For each provider, you'll need a different rclone. OR you can change your `rclone.conf`
+
+
+```apache
+[decypharr]
+type = webdav
+url = https://your-ip-or-domain:8282/webdav/
+vendor = other
+pacer_min_sleep = 0
+```
+
+You'll still be able to access the directories via `/mnt/remote/realdebrid, /mnt/remote/alldebrid` etc
+
+

docs/docs/index.md

@@ -1,20 +1,21 @@
-# DecyphArr
+# Decypharr
 
-![DecyphArr UI](images/main.png)
+![Decypharr UI](images/main.png)
 
-**DecyphArr** is an implementation of QbitTorrent with **Multiple Debrid service support**, written in Go.
+**Decypharr** is an implementation of QbitTorrent with **Multiple Debrid service support**, written in Go.
 
-## What is DecyphArr?
+## What is Decypharr?
+
+TLDR; Decypharr is a self-hosted, open-source torrent client that integrates with multiple Debrid services. It provides a user-friendly interface for managing torrents and supports popular media management applications like Sonarr and Radarr.
 
-DecyphArr combines the power of QBittorrent with popular Debrid services to enhance your media management. It provides a familiar interface for Sonarr, Radarr, and other \*Arr applications while leveraging the capabilities of Debrid providers.
 
 ## Key Features
 
-- 🔄 Mock Qbittorent API that supports Sonarr, Radarr, Lidarr and other Arr applications
-- 🖥️ Full-fledged UI for managing torrents
-- 🔌 Multiple Debrid providers support
-- 📁 WebDAV server support for each Debrid provider
-- 🔧 Repair Worker for missing files
+- Mock Qbittorent API that supports Sonarr, Radarr, Lidarr, and other Arr applications
+- Full-fledged UI for managing torrents
+- Multiple Debrid providers support
+- WebDAV server support for each Debrid provider
+- Repair Worker for missing files, symlinks etc
 
 ## Supported Debrid Providers
 
@@ -25,4 +26,4 @@ DecyphArr combines the power of QBittorrent with popular Debrid services to enha
 
 ## Getting Started
 
-Check out our [Installation Guide](installation.md) to get started with DecyphArr.
+Check out our [Installation Guide](installation.md) to get started with Decypharr.

docs/docs/installation.md

@@ -1,10 +1,10 @@
 # Installation
 
-There are multiple ways to install and run DecyphArr. Choose the method that works best for your setup.
+There are multiple ways to install and run Decypharr. Choose the method that works best for your setup.
 
 ## Docker Installation (Recommended)
 
-Docker is the easiest way to get started with DecyphArr.
+Docker is the easiest way to get started with Decypharr.
 
 ### Available Docker Registries
 
@@ -21,6 +21,25 @@ You can use either Docker Hub or GitHub Container Registry to pull the image:
 - `nightly`: The latest nightly build (usually unstable)
 - `experimental`: The latest experimental build (highly unstable)
 
+### Docker CLI Setup
+
+Pull the Docker image:
+```bash
+docker pull cy01/blackhole:latest
+```
+Run the Docker container:
+```bash
+docker run -d \
+  --name decypharr \
+  -p 8282:8282 \
+  -v /mnt/:/mnt \
+  -v ./config/:/app \
+  -e PUID=1000 \
+  -e PGID=1000 \
+  -e UMASK=002 \
+  cy01/blackhole:latest
+```
+
 ### Docker Compose Setup
 
 Create a `docker-compose.yml` file with the following content:
@@ -29,26 +48,20 @@ Create a `docker-compose.yml` file with the following content:
 version: '3.7'
 services:
   decypharr:
-    image: cy01/blackhole:latest # or cy01/blackhole:beta
+    image: cy01/blackhole:latest
     container_name: decypharr
     ports:
-      - "8282:8282" # qBittorrent
-      - "8181:8181" # Proxy
+      - "8282:8282"
     user: "1000:1000"
     volumes:
-      - /mnt/:/mnt
-      - ./configs/:/app # config.json must be in this directory
+      - /mnt/:/mnt # Mount your media directory
+      - ./config/:/app # config.json must be in this directory
     environment:
       - PUID=1000
       - PGID=1000
       - UMASK=002
       - QBIT_PORT=8282 # qBittorrent Port (optional)
-      - PORT=8181 # Proxy Port (optional)
     restart: unless-stopped
-    depends_on:
-      - rclone # If you are using rclone with docker
-
-
 ```
 
 Run the Docker Compose setup:
@@ -65,7 +78,39 @@ Create a configuration file (see Configuration)
 Run the binary:
 ```bash
 chmod +x decypharr
-./decypharr --config /path/to/config
+./decypharr --config /path/to/config/folder
 ```
 
-The config directory should contain your config.json file.
+The config directory should contain your config.json file.
+
+## config.json
+
+The `config.json` file is where you configure Decypharr. You can find a sample configuration file in the `configs` directory of the repository.
+
+You can also configure Decypharr through the web interface, but it's recommended to start with the config file for initial setup.
+
+```json
+{
+  "debrids": [
+    {
+      "name": "realdebrid",
+      "api_key": "your_api_key_here",
+      "folder": "/mnt/remote/realdebrid/__all__/",
+      "use_webdav": true
+    }
+  ],
+  "qbittorrent": {
+    "download_folder": "/mnt/symlinks/",
+    "categories": ["sonarr", "radarr"]
+  },
+  "use_auth": false,
+  "log_level": "info",
+  "port": "8282"
+}
+```
+
+### Few Notes
+
+- Make sure decypharr has access to the directories specified in the configuration file.
+- Ensure decypharr have write permissions to the qbittorrent download folder.
+- Make sure decypharr can write to the `./config/` directory.

docs/docs/usage.md

@@ -1,25 +1,25 @@
 # Usage Guide
 
-This guide will help you get started with DecyphArr after installation.
+This guide will help you get started with Decypharr after installation.
 
 ## Basic Setup
 
 1. Create your `config.json` file (see [Configuration](configuration/index.md) for details)
-2. Start the DecyphArr service using Docker or binary
+2. Start the Decypharr service using Docker or binary
 3. Access the UI at `http://localhost:8282` (or your configured host/port)
 4. Connect your Arr applications (Sonarr, Radarr, etc.)
 
 ## Connecting to Sonarr/Radarr
 
-To connect DecyphArr to your Sonarr or Radarr instance:
+To connect Decypharr to your Sonarr or Radarr instance:
 
 1. In Sonarr/Radarr, go to **Settings → Download Client → Add Client → qBittorrent**
 2. Configure the following settings:
-   - **Host**: `localhost` (or the IP of your DecyphArr server)
+   - **Host**: `localhost` (or the IP of your Decypharr server)
    - **Port**: `8282` (or your configured qBittorrent port)
    - **Username**: `http://sonarr:8989` (your Arr host with http/https)
    - **Password**: `sonarr_token` (your Arr API token)
-   - **Category**: e.g., `sonarr`, `radarr` (match what you configured in DecyphArr)
+   - **Category**: e.g., `sonarr`, `radarr` (match what you configured in Decypharr)
    - **Use SSL**: `No`
    - **Sequential Download**: `No` or `Yes` (if you want to download torrents locally instead of symlink)
 3. Click **Test** to verify the connection
@@ -29,11 +29,11 @@ To connect DecyphArr to your Sonarr or Radarr instance:
 
 ## Using the UI
 
-The DecyphArr UI provides a familiar qBittorrent-like interface with additional features for Debrid services:
+The Decypharr UI provides a familiar qBittorrent-like interface with additional features for Debrid services:
 
-- View and manage all your torrents
+- Add new torrents
 - Monitor download status
-- Check cache status across different Debrid providers
 - Access WebDAV functionality
+- Edit your configuration
 
 Access the UI at `http://localhost:8282` or your configured host/port.

docs/mkdocs.yml

@@ -69,6 +69,9 @@ nav:
       - Overview: features/index.md
       - Repair Worker: features/repair-worker.md
       - WebDAV: features/webdav.md
+  - Guides:
+      - Overview: guides/index.md
+      - Setting Up with Rclone: guides/rclone.md
   - Changelog: changelog.md
 
 

go.mod

@@ -1,22 +1,19 @@
 module github.com/sirrobot01/decypharr
 
-go 1.23.0
+go 1.24.0
 
-toolchain go1.23.2
+toolchain go1.24.3
 
 require (
 	github.com/anacrolix/torrent v1.55.0
-	github.com/beevik/etree v1.5.0
 	github.com/cavaliergopher/grab/v3 v3.0.1
-	github.com/elazarl/goproxy v0.0.0-20240726154733-8b0c20506380
-	github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2
 	github.com/go-chi/chi/v5 v5.1.0
-	github.com/goccy/go-json v0.10.5
+	github.com/go-co-op/gocron/v2 v2.16.1
 	github.com/google/uuid v1.6.0
 	github.com/gorilla/sessions v1.4.0
-	github.com/puzpuzpuz/xsync/v3 v3.5.1
+	github.com/robfig/cron/v3 v3.0.1
 	github.com/rs/zerolog v1.33.0
-	github.com/valyala/fastjson v1.6.4
+	github.com/stanNthe5/stringbuf v0.0.3
 	golang.org/x/crypto v0.33.0
 	golang.org/x/net v0.35.0
 	golang.org/x/sync v0.12.0
@@ -32,11 +29,10 @@ require (
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/gorilla/securecookie v1.1.2 // indirect
 	github.com/huandu/xstrings v1.3.2 // indirect
+	github.com/jonboulle/clockwork v0.5.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rogpeppe/go-internal v1.13.1 // indirect
-	github.com/stretchr/testify v1.10.0 // indirect
 	golang.org/x/sys v0.30.0 // indirect
-	golang.org/x/text v0.22.0 // indirect
 )

go.sum

@@ -36,8 +36,6 @@ github.com/anacrolix/tagflag v1.1.0/go.mod h1:Scxs9CV10NQatSmbyjqmqmeQNwGzlNe0CM
 github.com/anacrolix/torrent v1.55.0 h1:s9yh/YGdPmbN9dTa+0Inh2dLdrLQRvEAj1jdFW/Hdd8=
 github.com/anacrolix/torrent v1.55.0/go.mod h1:sBdZHBSZNj4de0m+EbYg7vvs/G/STubxu/GzzNbojsE=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
-github.com/beevik/etree v1.5.0 h1:iaQZFSDS+3kYZiGoc9uKeOkUY3nYMXOKLl6KIJxiJWs=
-github.com/beevik/etree v1.5.0/go.mod h1:gPNJNaBGVZ9AwsidazFZyygnd+0pAU38N4D+WemwKNs=
 github.com/benbjohnson/immutable v0.2.0/go.mod h1:uc6OHo6PN2++n98KHLxW8ef4W42ylHiQSENghE1ezxI=
 github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
 github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
@@ -61,10 +59,6 @@ github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25Kn
 github.com/eapache/go-resiliency v1.1.0/go.mod h1:kFI+JgMyC7bLPUVY133qvEBtVayf5mFgVsvEsIPBvNs=
 github.com/eapache/go-xerial-snappy v0.0.0-20180814174437-776d5712da21/go.mod h1:+020luEh2TKB4/GOp8oxxtq0Daoen/Cii55CzbTV6DU=
 github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFPTqq+I=
-github.com/elazarl/goproxy v0.0.0-20240726154733-8b0c20506380 h1:1NyRx2f4W4WBRyg0Kys0ZbaNmDDzZ2R/C7DTi+bbsJ0=
-github.com/elazarl/goproxy v0.0.0-20240726154733-8b0c20506380/go.mod h1:thX175TtLTzLj3p7N/Q9IiKZ7NF+p72cvL91emV0hzo=
-github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2 h1:dWB6v3RcOy03t/bUadywsbyrQwCqZeNIEX6M1OtSZOM=
-github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2/go.mod h1:gNh8nYJoAm43RfaxurUnxr+N1PwuFV3ZMl/efxlIlY8=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
@@ -76,13 +70,13 @@ github.com/glycerine/goconvey v0.0.0-20190315024820-982ee783a72e/go.mod h1:Ogl1T
 github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
 github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
 github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
+github.com/go-co-op/gocron/v2 v2.16.1 h1:ux/5zxVRveCaCuTtNI3DiOk581KC1KpJbpJFYUEVYwo=
+github.com/go-co-op/gocron/v2 v2.16.1/go.mod h1:opexeOFy5BplhsKdA7bzY9zeYih8I8/WNJ4arTIFPVc=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
 github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
-github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
 github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
 github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
@@ -130,6 +124,8 @@ github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63
 github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
 github.com/huandu/xstrings v1.3.2 h1:L18LIDzqlW6xN2rEkpdV8+oL/IXWJ1APd+vsdYy4Wdw=
 github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE=
+github.com/jonboulle/clockwork v0.5.0 h1:Hyh9A8u51kptdkR+cqRpT1EebBwTn1oK9YfGYbdFz6I=
+github.com/jonboulle/clockwork v0.5.0/go.mod h1:3mZlmanh0g2NDKO5TWZVJAfofYk64M7XN3SzBPjZF60=
 github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
 github.com/json-iterator/go v1.1.9/go.mod h1:KdQUCv79m/52Kvf8AW2vK1V8akMuk1QjK/uOdHXbAo4=
 github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
@@ -187,10 +183,9 @@ github.com/prometheus/procfs v0.0.0-20190117184657-bf6a532e95b1/go.mod h1:c3At6R
 github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
-github.com/puzpuzpuz/xsync/v3 v3.5.1 h1:GJYJZwO6IdxN/IKbneznS6yPkVC+c3zyY/j19c++5Fg=
-github.com/puzpuzpuz/xsync/v3 v3.5.1/go.mod h1:VjzYrABPabuM4KyBh1Ftq6u8nhwY5tBPKP9jpmh0nnA=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
-github.com/rogpeppe/go-charset v0.0.0-20180617210344-2471d30d28b4/go.mod h1:qgYeAmZ5ZIpBWTGllZSQnw97Dj+woV0toclVaRGI8pc=
+github.com/robfig/cron/v3 v3.0.1 h1:WdRxkvbJztn8LMz/QEvLN5sBU+xKpSqwwUO1Pjr4qDs=
+github.com/robfig/cron/v3 v3.0.1/go.mod h1:eQICP3HwyT7UooqI/z+Ov+PtYAWygg1TEWWzGIFLtro=
 github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
 github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
@@ -203,6 +198,8 @@ github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1
 github.com/smartystreets/assertions v0.0.0-20190215210624-980c5ac6f3ac/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
 github.com/smartystreets/goconvey v0.0.0-20181108003508-044398e4856c/go.mod h1:XDJAKZRPZ1CvBcN2aX5YOUTYGHki24fSF0Iv48Ibg0s=
 github.com/smartystreets/goconvey v0.0.0-20190306220146-200a235640ff/go.mod h1:KSQcGKpxUMHk3nbYzs/tIBAM2iDooCn0BmttHOJEbLs=
+github.com/stanNthe5/stringbuf v0.0.3 h1:3ChRipDckEY6FykaQ1Dowy3B+ZQa72EDBCasvT5+D1w=
+github.com/stanNthe5/stringbuf v0.0.3/go.mod h1:hii5Vr+mucoWkNJlIYQVp8YvuPtq45fFnJEAhcPf2cQ=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
@@ -214,13 +211,13 @@ github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf
 github.com/tinylib/msgp v1.0.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tinylib/msgp v1.1.0/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
 github.com/tinylib/msgp v1.1.2/go.mod h1:+d+yLhGm8mzTaHzB+wgMYrodPfmZrzkirds8fDWklFE=
-github.com/valyala/fastjson v1.6.4 h1:uAUNq9Z6ymTgGhcm0UynUAB6tlbakBrz6CQFax3BXVQ=
-github.com/valyala/fastjson v1.6.4/go.mod h1:CLCAqky6SMuOcxStkYQvblddUtoRxhYMGLrsQns1aXY=
 github.com/willf/bitset v1.1.9/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 github.com/willf/bitset v1.1.10/go.mod h1:RjeCKbqT1RxIR/KWY6phxZiaY1IyutSBfGjNPySAYV4=
 go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
@@ -269,8 +266,6 @@ golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
 golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
-golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
-golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/time v0.8.0 h1:9i3RxcPv3PZnitoVGMPDKZSq1xW1gK1Xy3ArNOGZfEg=
 golang.org/x/time v0.8.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
 golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=

internal/config/config.go

@@ -2,11 +2,13 @@ package config
 
 import (
 	"cmp"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/goccy/go-json"
 	"os"
 	"path/filepath"
+	"runtime"
+	"strings"
 	"sync"
 )
 
@@ -17,84 +19,75 @@ var (
 )
 
 type Debrid struct {
-	Name             string   `json:"name"`
-	Host             string   `json:"host"`
-	APIKey           string   `json:"api_key"`
-	DownloadAPIKeys  []string `json:"download_api_keys"`
-	Folder           string   `json:"folder"`
-	DownloadUncached bool     `json:"download_uncached"`
-	CheckCached      bool     `json:"check_cached"`
-	RateLimit        string   `json:"rate_limit"` // 200/minute or 10/second
-	Proxy            string   `json:"proxy"`
+	Name             string   `json:"name,omitempty"`
+	APIKey           string   `json:"api_key,omitempty"`
+	DownloadAPIKeys  []string `json:"download_api_keys,omitempty"`
+	Folder           string   `json:"folder,omitempty"`
+	DownloadUncached bool     `json:"download_uncached,omitempty"`
+	CheckCached      bool     `json:"check_cached,omitempty"`
+	RateLimit        string   `json:"rate_limit,omitempty"` // 200/minute or 10/second
+	Proxy            string   `json:"proxy,omitempty"`
+	AddSamples       bool     `json:"add_samples,omitempty"`
 
-	UseWebDav bool `json:"use_webdav"`
+	UseWebDav bool `json:"use_webdav,omitempty"`
 	WebDav
 }
 
 type QBitTorrent struct {
-	Username        string   `json:"username"`
-	Password        string   `json:"password"`
-	Port            string   `json:"port"`
-	DownloadFolder  string   `json:"download_folder"`
-	Categories      []string `json:"categories"`
-	RefreshInterval int      `json:"refresh_interval"`
-	SkipPreCache    bool     `json:"skip_pre_cache"`
+	Username        string   `json:"username,omitempty"`
+	Password        string   `json:"password,omitempty"`
+	Port            string   `json:"port,omitempty"` // deprecated
+	DownloadFolder  string   `json:"download_folder,omitempty"`
+	Categories      []string `json:"categories,omitempty"`
+	RefreshInterval int      `json:"refresh_interval,omitempty"`
+	SkipPreCache    bool     `json:"skip_pre_cache,omitempty"`
+	MaxDownloads    int      `json:"max_downloads,omitempty"`
 }
 
 type Arr struct {
-	Name             string `json:"name"`
-	Host             string `json:"host"`
-	Token            string `json:"token"`
-	Cleanup          bool   `json:"cleanup"`
-	SkipRepair       bool   `json:"skip_repair"`
-	DownloadUncached *bool  `json:"download_uncached"`
+	Name             string `json:"name,omitempty"`
+	Host             string `json:"host,omitempty"`
+	Token            string `json:"token,omitempty"`
+	Cleanup          bool   `json:"cleanup,omitempty"`
+	SkipRepair       bool   `json:"skip_repair,omitempty"`
+	DownloadUncached *bool  `json:"download_uncached,omitempty"`
 }
 
 type Repair struct {
-	Enabled     bool   `json:"enabled"`
-	Interval    string `json:"interval"`
-	RunOnStart  bool   `json:"run_on_start"`
-	ZurgURL     string `json:"zurg_url"`
-	AutoProcess bool   `json:"auto_process"`
-	UseWebDav   bool   `json:"use_webdav"`
-	Workers     int    `json:"workers"`
+	Enabled     bool   `json:"enabled,omitempty"`
+	Interval    string `json:"interval,omitempty"`
+	RunOnStart  bool   `json:"run_on_start,omitempty"`
+	ZurgURL     string `json:"zurg_url,omitempty"`
+	AutoProcess bool   `json:"auto_process,omitempty"`
+	UseWebDav   bool   `json:"use_webdav,omitempty"`
+	Workers     int    `json:"workers,omitempty"`
+	ReInsert    bool   `json:"reinsert,omitempty"`
 }
 
 type Auth struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
-}
-
-type WebDav struct {
-	TorrentsRefreshInterval      string `json:"torrents_refresh_interval"`
-	DownloadLinksRefreshInterval string `json:"download_links_refresh_interval"`
-	Workers                      int    `json:"workers"`
-	AutoExpireLinksAfter         string `json:"auto_expire_links_after"`
-
-	// Folder
-	FolderNaming string `json:"folder_naming"`
-
-	// Rclone
-	RcUrl  string `json:"rc_url"`
-	RcUser string `json:"rc_user"`
-	RcPass string `json:"rc_pass"`
+	Username string `json:"username,omitempty"`
+	Password string `json:"password,omitempty"`
 }
 
 type Config struct {
-	LogLevel       string      `json:"log_level"`
-	Debrids        []Debrid    `json:"debrids"`
-	MaxCacheSize   int         `json:"max_cache_size"`
-	QBitTorrent    QBitTorrent `json:"qbittorrent"`
-	Arrs           []Arr       `json:"arrs"`
-	Repair         Repair      `json:"repair"`
-	WebDav         WebDav      `json:"webdav"`
-	AllowedExt     []string    `json:"allowed_file_types"`
-	MinFileSize    string      `json:"min_file_size"` // Minimum file size to download, 10MB, 1GB, etc
-	MaxFileSize    string      `json:"max_file_size"` // Maximum file size to download (0 means no limit)
-	Path           string      `json:"-"`             // Path to save the config file
-	UseAuth        bool        `json:"use_auth"`
+	// server
+	BindAddress string `json:"bind_address,omitempty"`
+	URLBase     string `json:"url_base,omitempty"`
+	Port        string `json:"port,omitempty"`
+
+	LogLevel       string      `json:"log_level,omitempty"`
+	Debrids        []Debrid    `json:"debrids,omitempty"`
+	QBitTorrent    QBitTorrent `json:"qbittorrent,omitempty"`
+	Arrs           []Arr       `json:"arrs,omitempty"`
+	Repair         Repair      `json:"repair,omitempty"`
+	WebDav         WebDav      `json:"webdav,omitempty"`
+	AllowedExt     []string    `json:"allowed_file_types,omitempty"`
+	MinFileSize    string      `json:"min_file_size,omitempty"` // Minimum file size to download, 10MB, 1GB, etc
+	MaxFileSize    string      `json:"max_file_size,omitempty"` // Maximum file size to download (0 means no limit)
+	Path           string      `json:"-"`                       // Path to save the config file
+	UseAuth        bool        `json:"use_auth,omitempty"`
 	Auth           *Auth       `json:"-"`
-	DiscordWebhook string      `json:"discord_webhook_url"`
+	DiscordWebhook string      `json:"discord_webhook_url,omitempty"`
 }
 
 func (c *Config) JsonFile() string {
@@ -112,29 +105,21 @@ func (c *Config) loadConfig() error {
 	c.Path = configPath
 	file, err := os.ReadFile(c.JsonFile())
 	if err != nil {
-		return err
+		if os.IsNotExist(err) {
+			fmt.Printf("Config file not found, creating a new one at %s\n", c.JsonFile())
+			// Create a default config file if it doesn't exist
+			if err := c.createConfig(c.Path); err != nil {
+				return fmt.Errorf("failed to create config file: %w", err)
+			}
+			return c.Save()
+		}
+		return fmt.Errorf("error reading config file: %w", err)
 	}
 
 	if err := json.Unmarshal(file, &c); err != nil {
 		return fmt.Errorf("error unmarshaling config: %w", err)
 	}
-
-	for i, debrid := range c.Debrids {
-		c.Debrids[i] = c.updateDebrid(debrid)
-	}
-
-	if len(c.AllowedExt) == 0 {
-		c.AllowedExt = getDefaultExtensions()
-	}
-
-	// Load the auth file
-	c.Auth = c.GetAuth()
-
-	//Validate the config
-	if err := validateConfig(c); err != nil {
-		return err
-	}
-
+	c.setDefaults()
 	return nil
 }
 
@@ -143,75 +128,66 @@ func validateDebrids(debrids []Debrid) error {
 		return errors.New("no debrids configured")
 	}
 
-	errChan := make(chan error, len(debrids))
-	var wg sync.WaitGroup
-
 	for _, debrid := range debrids {
 		// Basic field validation
-		if debrid.Host == "" {
-			return errors.New("debrid host is required")
-		}
 		if debrid.APIKey == "" {
 			return errors.New("debrid api key is required")
 		}
 		if debrid.Folder == "" {
 			return errors.New("debrid folder is required")
 		}
-
-		// Check folder existence
-		//wg.Add(1)
-		//go func(folder string) {
-		//	defer wg.Done()
-		//	if _, err := os.Stat(folder); os.IsNotExist(err) {
-		//		errChan <- fmt.Errorf("debrid folder does not exist: %s", folder)
-		//	}
-		//}(debrid.Folder)
 	}
 
-	// Wait for all checks to complete
-	go func() {
-		wg.Wait()
-		close(errChan)
-	}()
+	return nil
+}
 
-	// Return first error if any
-	if err := <-errChan; err != nil {
+func validateQbitTorrent(config *QBitTorrent) error {
+	if config.DownloadFolder == "" {
+		return errors.New("qbittorent download folder is required")
+	}
+	if _, err := os.Stat(config.DownloadFolder); os.IsNotExist(err) {
+		return fmt.Errorf("qbittorent download folder(%s) does not exist", config.DownloadFolder)
+	}
+	return nil
+}
+
+func validateRepair(config *Repair) error {
+	if !config.Enabled {
+		return nil
+	}
+	if config.Interval == "" {
+		return errors.New("repair interval is required")
+	}
+	return nil
+}
+
+func ValidateConfig(config *Config) error {
+	// Run validations concurrently
+
+	if err := validateDebrids(config.Debrids); err != nil {
+		return err
+	}
+
+	if err := validateQbitTorrent(&config.QBitTorrent); err != nil {
+		return err
+	}
+
+	if err := validateRepair(&config.Repair); err != nil {
 		return err
 	}
 
 	return nil
 }
 
-//func validateQbitTorrent(config *QBitTorrent) error {
-//	if config.DownloadFolder == "" {
-//		return errors.New("qbittorent download folder is required")
-//	}
-//	if _, err := os.Stat(config.DownloadFolder); os.IsNotExist(err) {
-//		return fmt.Errorf("qbittorent download folder(%s) does not exist", config.DownloadFolder)
-//	}
-//	return nil
-//}
-
-func validateConfig(config *Config) error {
-	// Run validations concurrently
-
-	if err := validateDebrids(config.Debrids); err != nil {
-		return fmt.Errorf("debrids validation error: %w", err)
-	}
-
-	return nil
-}
-
-func SetConfigPath(path string) error {
+func SetConfigPath(path string) {
 	configPath = path
-	return nil
 }
 
 func Get() *Config {
 	once.Do(func() {
 		instance = &Config{} // Initialize instance first
 		if err := instance.loadConfig(); err != nil {
-			fmt.Fprintf(os.Stderr, "configuration Error: %v\n", err)
+			_, _ = fmt.Fprintf(os.Stderr, "configuration Error: %v\n", err)
 			os.Exit(1)
 		}
 	})
@@ -223,7 +199,7 @@ func (c *Config) GetMinFileSize() int64 {
 	if c.MinFileSize == "" {
 		return 0
 	}
-	s, err := parseSize(c.MinFileSize)
+	s, err := ParseSize(c.MinFileSize)
 	if err != nil {
 		return 0
 	}
@@ -235,7 +211,7 @@ func (c *Config) GetMaxFileSize() int64 {
 	if c.MaxFileSize == "" {
 		return 0
 	}
-	s, err := parseSize(c.MaxFileSize)
+	s, err := ParseSize(c.MaxFileSize)
 	if err != nil {
 		return 0
 	}
@@ -280,7 +256,11 @@ func (c *Config) SaveAuth(auth *Auth) error {
 	return os.WriteFile(c.AuthFile(), data, 0644)
 }
 
-func (c *Config) NeedsSetup() bool {
+func (c *Config) NeedsSetup() error {
+	return ValidateConfig(c)
+}
+
+func (c *Config) NeedsAuth() bool {
 	if c.UseAuth {
 		return c.GetAuth().Username == ""
 	}
@@ -288,6 +268,8 @@ func (c *Config) NeedsSetup() bool {
 }
 
 func (c *Config) updateDebrid(d Debrid) Debrid {
+	workers := runtime.NumCPU() * 50
+	perDebrid := workers / len(c.Debrids)
 
 	if len(d.DownloadAPIKeys) == 0 {
 		d.DownloadAPIKeys = append(d.DownloadAPIKeys, d.APIKey)
@@ -304,7 +286,7 @@ func (c *Config) updateDebrid(d Debrid) Debrid {
 		d.DownloadLinksRefreshInterval = cmp.Or(c.WebDav.DownloadLinksRefreshInterval, "40m") // 40 minutes
 	}
 	if d.Workers == 0 {
-		d.Workers = cmp.Or(c.WebDav.Workers, 30) // 30 workers
+		d.Workers = perDebrid
 	}
 	if d.FolderNaming == "" {
 		d.FolderNaming = cmp.Or(c.WebDav.FolderNaming, "original_no_ext")
@@ -312,5 +294,88 @@ func (c *Config) updateDebrid(d Debrid) Debrid {
 	if d.AutoExpireLinksAfter == "" {
 		d.AutoExpireLinksAfter = cmp.Or(c.WebDav.AutoExpireLinksAfter, "3d") // 2 days
 	}
+
+	// Merge debrid specified directories with global directories
+
+	directories := c.WebDav.Directories
+	if directories == nil {
+		directories = make(map[string]WebdavDirectories)
+	}
+
+	for name, dir := range d.Directories {
+		directories[name] = dir
+	}
+	d.Directories = directories
+
+	d.RcUrl = cmp.Or(d.RcUrl, c.WebDav.RcUrl)
+	d.RcUser = cmp.Or(d.RcUser, c.WebDav.RcUser)
+	d.RcPass = cmp.Or(d.RcPass, c.WebDav.RcPass)
+
 	return d
 }
+
+func (c *Config) setDefaults() {
+	for i, debrid := range c.Debrids {
+		c.Debrids[i] = c.updateDebrid(debrid)
+	}
+
+	if len(c.AllowedExt) == 0 {
+		c.AllowedExt = getDefaultExtensions()
+	}
+
+	c.Port = cmp.Or(c.Port, c.QBitTorrent.Port)
+
+	if c.URLBase == "" {
+		c.URLBase = "/"
+	}
+	// validate url base starts with /
+	if !strings.HasPrefix(c.URLBase, "/") {
+		c.URLBase = "/" + c.URLBase
+	}
+	if !strings.HasSuffix(c.URLBase, "/") {
+		c.URLBase += "/"
+	}
+
+	// Load the auth file
+	c.Auth = c.GetAuth()
+}
+
+func (c *Config) Save() error {
+
+	c.setDefaults()
+
+	data, err := json.MarshalIndent(c, "", "  ")
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(c.JsonFile(), data, 0644); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (c *Config) createConfig(path string) error {
+	// Create the directory if it doesn't exist
+	if err := os.MkdirAll(path, 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %w", err)
+	}
+
+	c.Path = path
+	c.URLBase = "/"
+	c.Port = "8282"
+	c.LogLevel = "info"
+	c.UseAuth = true
+	c.QBitTorrent = QBitTorrent{
+		DownloadFolder:  filepath.Join(path, "downloads"),
+		Categories:      []string{"sonarr", "radarr"},
+		RefreshInterval: 15,
+	}
+	return nil
+}
+
+// Reload forces a reload of the configuration from disk
+func Reload() {
+	instance = nil
+	once = sync.Once{}
+}

internal/config/misc.go

@@ -50,7 +50,7 @@ func getDefaultExtensions() []string {
 	return unique
 }
 
-func parseSize(sizeStr string) (int64, error) {
+func ParseSize(sizeStr string) (int64, error) {
 	sizeStr = strings.ToUpper(strings.TrimSpace(sizeStr))
 
 	// Absolute size-based cache

internal/config/webdav.go

@@ -0,0 +1,26 @@
+package config
+
+type WebdavDirectories struct {
+	Filters map[string]string `json:"filters,omitempty"`
+	//SaveStrms bool              `json:"save_streams,omitempty"`
+}
+
+type WebDav struct {
+	TorrentsRefreshInterval      string `json:"torrents_refresh_interval,omitempty"`
+	DownloadLinksRefreshInterval string `json:"download_links_refresh_interval,omitempty"`
+	Workers                      int    `json:"workers,omitempty"`
+	AutoExpireLinksAfter         string `json:"auto_expire_links_after,omitempty"`
+	ServeFromRclone              bool   `json:"serve_from_rclone,omitempty"`
+
+	// Folder
+	FolderNaming string `json:"folder_naming,omitempty"`
+
+	// Rclone
+	RcUrl         string `json:"rc_url,omitempty"`
+	RcUser        string `json:"rc_user,omitempty"`
+	RcPass        string `json:"rc_pass,omitempty"`
+	RcRefreshDirs string `json:"rc_refresh_dirs,omitempty"` // comma separated list of directories to refresh
+
+	// Directories
+	Directories map[string]WebdavDirectories `json:"directories,omitempty"`
+}

internal/logger/logger.go

@@ -45,7 +45,24 @@ func New(prefix string) zerolog.Logger {
 		TimeFormat: "2006-01-02 15:04:05",
 		NoColor:    false, // Set to true if you don't want colors
 		FormatLevel: func(i interface{}) string {
-			return strings.ToUpper(fmt.Sprintf("| %-6s|", i))
+			var colorCode string
+			switch strings.ToLower(fmt.Sprintf("%s", i)) {
+			case "debug":
+				colorCode = "\033[36m"
+			case "info":
+				colorCode = "\033[32m"
+			case "warn":
+				colorCode = "\033[33m"
+			case "error":
+				colorCode = "\033[31m"
+			case "fatal":
+				colorCode = "\033[35m"
+			case "panic":
+				colorCode = "\033[41m"
+			default:
+				colorCode = "\033[37m" // White
+			}
+			return fmt.Sprintf("%s| %-6s|\033[0m", colorCode, strings.ToUpper(fmt.Sprintf("%s", i)))
 		},
 		FormatMessage: func(i interface{}) string {
 			return fmt.Sprintf("[%s] %v", prefix, i)
@@ -89,7 +106,7 @@ func New(prefix string) zerolog.Logger {
 	return logger
 }
 
-func GetDefaultLogger() zerolog.Logger {
+func Default() zerolog.Logger {
 	once.Do(func() {
 		logger = New("decypharr")
 	})

internal/request/discord.go

@@ -2,8 +2,8 @@ package request
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"io"
 	"net/http"

internal/request/errors.go

@@ -27,3 +27,9 @@ var ErrLinkBroken = &HTTPError{
 	Message:    "File is unavailable",
 	Code:       "file_unavailable",
 }
+
+var TorrentNotFoundError = &HTTPError{
+	StatusCode: 404,
+	Message:    "Torrent not found",
+	Code:       "torrent_not_found",
+}

internal/request/request.go

@@ -5,8 +5,9 @@ import (
 	"compress/gzip"
 	"context"
 	"crypto/tls"
+	"encoding/json"
+	"errors"
 	"fmt"
-	"github.com/goccy/go-json"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"golang.org/x/net/proxy"
@@ -17,7 +18,6 @@ import (
 	"net"
 	"net/http"
 	"net/url"
-	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -62,23 +62,6 @@ type Client struct {
 	retryableStatus map[int]struct{}
 	logger          zerolog.Logger
 	proxy           string
-
-	// cooldown
-	statusCooldowns   map[int]time.Duration
-	statusCooldownsMu sync.RWMutex
-	lastStatusTime    map[int]time.Time
-	lastStatusTimeMu  sync.RWMutex
-}
-
-func WithStatusCooldown(statusCode int, cooldown time.Duration) ClientOption {
-	return func(c *Client) {
-		c.statusCooldownsMu.Lock()
-		if c.statusCooldowns == nil {
-			c.statusCooldowns = make(map[int]time.Duration)
-		}
-		c.statusCooldowns[statusCode] = cooldown
-		c.statusCooldownsMu.Unlock()
-	}
 }
 
 // WithMaxRetries sets the maximum number of retry attempts
@@ -138,6 +121,7 @@ func WithTransport(transport *http.Transport) ClientOption {
 // WithRetryableStatus adds status codes that should trigger a retry
 func WithRetryableStatus(statusCodes ...int) ClientOption {
 	return func(c *Client) {
+		c.retryableStatus = make(map[int]struct{}) // reset the map
 		for _, code := range statusCodes {
 			c.retryableStatus[code] = struct{}{}
 		}
@@ -194,43 +178,10 @@ func (c *Client) Do(req *http.Request) (*http.Response, error) {
 		}
 		c.headersMu.RUnlock()
 
-		if attempt > 0 && resp != nil {
-			c.statusCooldownsMu.RLock()
-			cooldown, exists := c.statusCooldowns[resp.StatusCode]
-			c.statusCooldownsMu.RUnlock()
-
-			if exists {
-				c.lastStatusTimeMu.RLock()
-				lastTime, timeExists := c.lastStatusTime[resp.StatusCode]
-				c.lastStatusTimeMu.RUnlock()
-
-				if timeExists {
-					elapsed := time.Since(lastTime)
-					if elapsed < cooldown {
-						// We need to wait longer for this status code
-						waitTime := cooldown - elapsed
-						select {
-						case <-req.Context().Done():
-							return nil, req.Context().Err()
-						case <-time.After(waitTime):
-							// Continue after waiting
-						}
-					}
-				}
-			}
-		}
-
 		resp, err = c.doRequest(req)
-
-		if err == nil {
-			c.lastStatusTimeMu.Lock()
-			c.lastStatusTime[resp.StatusCode] = time.Now()
-			c.lastStatusTimeMu.Unlock()
-		}
-
 		if err != nil {
 			// Check if this is a network error that might be worth retrying
-			if attempt < c.maxRetries {
+			if isRetryableError(err) && attempt < c.maxRetries {
 				// Apply backoff with jitter
 				jitter := time.Duration(rand.Int63n(int64(backoff / 4)))
 				sleepTime := backoff + jitter
@@ -321,12 +272,10 @@ func New(options ...ClientOption) *Client {
 			http.StatusServiceUnavailable:  struct{}{},
 			http.StatusGatewayTimeout:      struct{}{},
 		},
-		logger:          logger.New("request"),
-		timeout:         60 * time.Second,
-		proxy:           "",
-		headers:         make(map[string]string), // Initialize headers map
-		statusCooldowns: make(map[int]time.Duration),
-		lastStatusTime:  make(map[int]time.Time),
+		logger:  logger.New("request"),
+		timeout: 60 * time.Second,
+		proxy:   "",
+		headers: make(map[string]string),
 	}
 
 	// default http client
@@ -345,28 +294,7 @@ func New(options ...ClientOption) *Client {
 			TLSClientConfig: &tls.Config{
 				InsecureSkipVerify: client.skipTLSVerify,
 			},
-			// Connection pooling
-			MaxIdleConns:        100,
-			MaxIdleConnsPerHost: 50,
-			MaxConnsPerHost:     100,
-
-			// Timeouts
-			IdleConnTimeout:       90 * time.Second,
-			TLSHandshakeTimeout:   10 * time.Second,
-			ResponseHeaderTimeout: 10 * time.Second,
-			ExpectContinueTimeout: 1 * time.Second,
-
-			// TCP keep-alive
-			DialContext: (&net.Dialer{
-				Timeout:   30 * time.Second,
-				KeepAlive: 30 * time.Second,
-			}).DialContext,
-
-			// Enable HTTP/2
-			ForceAttemptHTTP2: true,
-
-			// Disable compression to save CPU
-			DisableCompression: false,
+			DisableKeepAlives: false,
 		}
 
 		// Configure proxy if needed
@@ -413,29 +341,34 @@ func New(options ...ClientOption) *Client {
 }
 
 func ParseRateLimit(rateStr string) *rate.Limiter {
-	if rateStr == "" {
-		return nil
-	}
-	re := regexp.MustCompile(`(\d+)/(minute|second)`)
-	matches := re.FindStringSubmatch(rateStr)
-	if len(matches) != 3 {
+	parts := strings.SplitN(rateStr, "/", 2)
+	if len(parts) != 2 {
 		return nil
 	}
 
-	count, err := strconv.Atoi(matches[1])
-	if err != nil {
+	// parse count
+	count, err := strconv.Atoi(strings.TrimSpace(parts[0]))
+	if err != nil || count <= 0 {
 		return nil
 	}
 
-	unit := matches[2]
+	// normalize unit
+	unit := strings.ToLower(strings.TrimSpace(parts[1]))
+	unit = strings.TrimSuffix(unit, "s")
+	burstSize := int(math.Ceil(float64(count) * 0.1))
+	if burstSize < 1 {
+		burstSize = 1
+	}
+	if burstSize > count {
+		burstSize = count
+	}
 	switch unit {
-	case "minute":
-		reqsPerSecond := float64(count) / 60.0
-		burstSize := int(math.Max(30, float64(count)*0.25))
-		return rate.NewLimiter(rate.Limit(reqsPerSecond), burstSize)
-	case "second":
-		burstSize := int(math.Max(30, float64(count)*5))
+	case "minute", "min":
+		return rate.NewLimiter(rate.Limit(float64(count)/60.0), burstSize)
+	case "second", "sec":
 		return rate.NewLimiter(rate.Limit(float64(count)), burstSize)
+	case "hour", "hr":
+		return rate.NewLimiter(rate.Limit(float64(count)/3600.0), burstSize)
 	default:
 		return nil
 	}
@@ -451,21 +384,28 @@ func JSONResponse(w http.ResponseWriter, data interface{}, code int) {
 }
 
 func Gzip(body []byte) []byte {
-
-	var b bytes.Buffer
 	if len(body) == 0 {
 		return nil
 	}
-	gz := gzip.NewWriter(&b)
-	_, err := gz.Write(body)
+
+	// Check if the pool is nil
+	buf := bytes.NewBuffer(make([]byte, 0, len(body)))
+
+	gz, err := gzip.NewWriterLevel(buf, gzip.BestSpeed)
 	if err != nil {
 		return nil
 	}
-	err = gz.Close()
-	if err != nil {
+
+	if _, err := gz.Write(body); err != nil {
 		return nil
 	}
-	return b.Bytes()
+	if err := gz.Close(); err != nil {
+		return nil
+	}
+	result := make([]byte, buf.Len())
+	copy(result, buf.Bytes())
+
+	return result
 }
 
 func Default() *Client {
@@ -474,3 +414,30 @@ func Default() *Client {
 	})
 	return instance
 }
+
+func isRetryableError(err error) bool {
+	errString := err.Error()
+
+	// Connection reset and other network errors
+	if strings.Contains(errString, "connection reset by peer") ||
+		strings.Contains(errString, "read: connection reset") ||
+		strings.Contains(errString, "connection refused") ||
+		strings.Contains(errString, "network is unreachable") ||
+		strings.Contains(errString, "connection timed out") ||
+		strings.Contains(errString, "no such host") ||
+		strings.Contains(errString, "i/o timeout") ||
+		strings.Contains(errString, "unexpected EOF") ||
+		strings.Contains(errString, "TLS handshake timeout") {
+		return true
+	}
+
+	// Check for net.Error type which can provide more information
+	var netErr net.Error
+	if errors.As(err, &netErr) {
+		// Retry on timeout errors and temporary errors
+		return netErr.Timeout() || netErr.Temporary()
+	}
+
+	// Not a retryable error
+	return false
+}

internal/utils/debouncer.go

@@ -0,0 +1,43 @@
+package utils
+
+import (
+	"sync"
+	"time"
+)
+
+type Debouncer[T any] struct {
+	mu       sync.Mutex
+	timer    *time.Timer
+	interval time.Duration
+	caller   func(arg T)
+}
+
+func NewDebouncer[T any](interval time.Duration, caller func(arg T)) *Debouncer[T] {
+	return &Debouncer[T]{
+		interval: interval,
+		caller:   caller,
+	}
+}
+
+func (d *Debouncer[T]) Call(arg T) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if d.timer != nil {
+		d.timer.Stop()
+	}
+
+	d.timer = time.AfterFunc(d.interval, func() {
+		d.caller(arg)
+	})
+}
+
+func (d *Debouncer[T]) Stop() {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if d.timer != nil {
+		d.timer.Stop()
+		d.timer = nil
+	}
+}

internal/utils/file.go

@@ -1,2 +1,21 @@
 package utils
 
+import (
+	"net/url"
+	"strings"
+)
+
+func PathUnescape(path string) string {
+
+	// try to use url.PathUnescape
+	if unescaped, err := url.PathUnescape(path); err == nil {
+		return unescaped
+	}
+
+	// unescape %
+	unescapedPath := strings.ReplaceAll(path, "%25", "%")
+
+	// add others
+
+	return unescapedPath
+}

internal/utils/magnet.go

@@ -20,6 +20,10 @@ import (
 	"time"
 )
 
+var (
+	hexRegex = regexp.MustCompile("^[0-9a-fA-F]{40}$")
+)
+
 type Magnet struct {
 	Name     string
 	InfoHash string
@@ -188,7 +192,6 @@ func ExtractInfoHash(magnetDesc string) string {
 
 func processInfoHash(input string) (string, error) {
 	// Regular expression for a valid 40-character hex infohash
-	hexRegex := regexp.MustCompile("^[0-9a-fA-F]{40}$")
 
 	// If it's already a valid hex infohash, return it as is
 	if hexRegex.MatchString(input) {

internal/utils/misc.go

@@ -13,3 +13,12 @@ outer:
 	}
 	return result
 }
+
+func Contains(slice []string, value string) bool {
+	for _, item := range slice {
+		if item == value {
+			return true
+		}
+	}
+	return false
+}

internal/utils/regex.go

@@ -7,14 +7,17 @@ import (
 )
 
 var (
-	VIDEOMATCH = "(?i)(\\.)(webm|m4v|3gp|nsv|ty|strm|rm|rmvb|m3u|ifo|mov|qt|divx|xvid|bivx|nrg|pva|wmv|asf|asx|ogm|ogv|m2v|avi|bin|dat|dvr-ms|mpg|mpeg|mp4|avc|vp3|svq3|nuv|viv|dv|fli|flv|wpl|img|iso|vob|mkv|mk3d|ts|wtv|m2ts)$"
-	MUSICMATCH = "(?i)(\\.)(mp2|mp3|m4a|m4b|m4p|ogg|oga|opus|wma|wav|wv|flac|ape|aif|aiff|aifc)$"
+	videoMatch  = "(?i)(\\.)(webm|m4v|3gp|nsv|ty|strm|rm|rmvb|m3u|ifo|mov|qt|divx|xvid|bivx|nrg|pva|wmv|asf|asx|ogm|ogv|m2v|avi|bin|dat|dvr-ms|mpg|mpeg|mp4|avc|vp3|svq3|nuv|viv|dv|fli|flv|wpl|img|iso|vob|mkv|mk3d|ts|wtv|m2ts)$"
+	musicMatch  = "(?i)(\\.)(mp2|mp3|m4a|m4b|m4p|ogg|oga|opus|wma|wav|wv|flac|ape|aif|aiff|aifc)$"
+	sampleMatch = `(?i)(^|[\s/\\])(sample|trailer|thumb|special|extras?)s?[-/]|(\((sample|trailer|thumb|special|extras?)s?\))|(-\s*(sample|trailer|thumb|special|extras?)s?)`
 )
 
-var SAMPLEMATCH = `(?i)(^|[\\/])(sample|trailer|thumb|special|extras?)s?([\s._-]|$|/)|(\(sample\))|(-\s*sample)`
+var (
+	mediaRegex  = regexp.MustCompile(videoMatch + "|" + musicMatch)
+	sampleRegex = regexp.MustCompile(sampleMatch)
+)
 
-func RegexMatch(regex string, value string) bool {
-	re := regexp.MustCompile(regex)
+func RegexMatch(re *regexp.Regexp, value string) bool {
 	return re.MatchString(value)
 }
 
@@ -37,10 +40,7 @@ func RemoveInvalidChars(value string) string {
 }
 
 func RemoveExtension(value string) string {
-	re := regexp.MustCompile(VIDEOMATCH + "|" + MUSICMATCH)
-
-	// Find the last index of the matched extension
-	loc := re.FindStringIndex(value)
+	loc := mediaRegex.FindStringIndex(value)
 	if loc != nil {
 		return value[:loc[0]]
 	} else {
@@ -49,10 +49,12 @@ func RemoveExtension(value string) string {
 }
 
 func IsMediaFile(path string) bool {
-	mediaPattern := VIDEOMATCH + "|" + MUSICMATCH
-	return RegexMatch(mediaPattern, path)
+	return RegexMatch(mediaRegex, path)
 }
 
 func IsSampleFile(path string) bool {
-	return RegexMatch(SAMPLEMATCH, path)
+	if strings.HasSuffix(strings.ToLower(path), "sample.mkv") {
+		return true
+	}
+	return RegexMatch(sampleRegex, path)
 }

internal/utils/scheduler.go

@@ -0,0 +1,76 @@
+package utils
+
+import (
+	"context"
+	"fmt"
+	"github.com/go-co-op/gocron/v2"
+	"github.com/robfig/cron/v3"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func ScheduleJob(ctx context.Context, interval string, loc *time.Location, jobFunc func()) (gocron.Scheduler, error) {
+	if loc == nil {
+		loc = time.Local
+	}
+	s, err := gocron.NewScheduler(gocron.WithLocation(loc))
+	if err != nil {
+		return s, fmt.Errorf("failed to create scheduler: %w", err)
+	}
+	jd, err := ConvertToJobDef(interval)
+	if err != nil {
+		return s, fmt.Errorf("failed to convert interval to job definition: %w", err)
+	}
+	// Schedule the job
+	if _, err = s.NewJob(jd, gocron.NewTask(jobFunc), gocron.WithContext(ctx)); err != nil {
+		return s, fmt.Errorf("failed to create job: %w", err)
+	}
+	return s, nil
+}
+
+// ConvertToJobDef converts a string interval to a gocron.JobDefinition.
+func ConvertToJobDef(interval string) (gocron.JobDefinition, error) {
+	// Parse the interval string
+	// Interval could be in the format "1h", "30m", "15s" or "1h30m" or "04:05"
+	var jd gocron.JobDefinition
+
+	if t, ok := parseClockTime(interval); ok {
+		return gocron.DailyJob(1, gocron.NewAtTimes(
+			gocron.NewAtTime(uint(t.Hour()), uint(t.Minute()), uint(t.Second())),
+		)), nil
+	}
+
+	if _, err := cron.ParseStandard(interval); err == nil {
+		return gocron.CronJob(interval, false), nil
+	}
+
+	if dur, err := time.ParseDuration(interval); err == nil {
+		return gocron.DurationJob(dur), nil
+	}
+
+	return jd, fmt.Errorf("invalid interval format: %s", interval)
+}
+
+func parseClockTime(s string) (time.Time, bool) {
+	parts := strings.Split(s, ":")
+	if len(parts) != 2 {
+		return time.Time{}, false
+	}
+	h, err := strconv.Atoi(parts[0])
+	if err != nil || h < 0 || h > 23 {
+		return time.Time{}, false
+	}
+	m, err := strconv.Atoi(parts[1])
+	if err != nil || m < 0 || m > 59 {
+		return time.Time{}, false
+	}
+	now := time.Now()
+	// build a time.Time for today at h:m:00 in the local zone
+	t := time.Date(
+		now.Year(), now.Month(), now.Day(),
+		h, m, 0, 0,
+		time.Local,
+	)
+	return t, true
+}

main.go

@@ -5,10 +5,7 @@ import (
 	"flag"
 	"github.com/sirrobot01/decypharr/cmd/decypharr"
 	"github.com/sirrobot01/decypharr/internal/config"
-	"github.com/sirrobot01/decypharr/pkg/version"
 	"log"
-	"net/http"
-	_ "net/http/pprof" // registers pprof handlers
 	"os"
 	"os/signal"
 	"runtime/debug"
@@ -22,26 +19,13 @@ func main() {
 			debug.PrintStack()
 		}
 	}()
-
-	if version.GetInfo().Channel == "dev" {
-		log.Println("Running in dev mode")
-		go func() {
-			if err := http.ListenAndServe(":6060", nil); err != nil {
-				log.Fatalf("pprof server failed: %v", err)
-			}
-		}()
-	}
 	var configPath string
 	flag.StringVar(&configPath, "config", "/data", "path to the data folder")
 	flag.Parse()
-
-	if err := config.SetConfigPath(configPath); err != nil {
-		log.Fatal(err)
-	}
-
+	config.SetConfigPath(configPath)
 	config.Get()
 
-	// Create a context that's cancelled on SIGINT/SIGTERM
+	// Create a context canceled on SIGINT/SIGTERM
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer stop()
 

pkg/arr/arr.go

@@ -2,9 +2,12 @@ package arr
 
 import (
 	"bytes"
+	"context"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
+	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
+	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"io"
 	"net/http"
@@ -113,8 +116,15 @@ func (a *Arr) Validate() error {
 }
 
 type Storage struct {
-	Arrs map[string]*Arr // name -> arr
-	mu   sync.RWMutex
+	Arrs   map[string]*Arr // name -> arr
+	mu     sync.Mutex
+	logger zerolog.Logger
+}
+
+func (as *Storage) Cleanup() {
+	as.mu.Lock()
+	defer as.mu.Unlock()
+	as.Arrs = make(map[string]*Arr)
 }
 
 func InferType(host, name string) Type {
@@ -139,7 +149,8 @@ func NewStorage() *Storage {
 		arrs[name] = New(name, a.Host, a.Token, a.Cleanup, a.SkipRepair, a.DownloadUncached)
 	}
 	return &Storage{
-		Arrs: arrs,
+		Arrs:   arrs,
+		logger: logger.New("arr"),
 	}
 }
 
@@ -153,14 +164,14 @@ func (as *Storage) AddOrUpdate(arr *Arr) {
 }
 
 func (as *Storage) Get(name string) *Arr {
-	as.mu.RLock()
-	defer as.mu.RUnlock()
+	as.mu.Lock()
+	defer as.mu.Unlock()
 	return as.Arrs[name]
 }
 
 func (as *Storage) GetAll() []*Arr {
-	as.mu.RLock()
-	defer as.mu.RUnlock()
+	as.mu.Lock()
+	defer as.mu.Unlock()
 	arrs := make([]*Arr, 0, len(as.Arrs))
 	for _, arr := range as.Arrs {
 		if arr.Host != "" && arr.Token != "" {
@@ -170,6 +181,43 @@ func (as *Storage) GetAll() []*Arr {
 	return arrs
 }
 
+func (as *Storage) Clear() {
+	as.mu.Lock()
+	defer as.mu.Unlock()
+	as.Arrs = make(map[string]*Arr)
+}
+
+func (as *Storage) StartSchedule(ctx context.Context) error {
+
+	ticker := time.NewTicker(10 * time.Second)
+
+	select {
+	case <-ticker.C:
+		as.cleanupArrsQueue()
+	case <-ctx.Done():
+		ticker.Stop()
+		return nil
+	}
+	return nil
+}
+
+func (as *Storage) cleanupArrsQueue() {
+	arrs := make([]*Arr, 0)
+	for _, arr := range as.Arrs {
+		if !arr.Cleanup {
+			continue
+		}
+		arrs = append(arrs, arr)
+	}
+	if len(arrs) > 0 {
+		for _, arr := range arrs {
+			if err := arr.CleanupQueue(); err != nil {
+				as.logger.Error().Err(err).Msgf("Failed to cleanup arr %s", arr.Name)
+			}
+		}
+	}
+}
+
 func (a *Arr) Refresh() error {
 	payload := struct {
 		Name string `json:"name"`

pkg/arr/content.go

@@ -2,8 +2,8 @@ package arr
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
 	"golang.org/x/sync/errgroup"
 	"net/http"
 	"strconv"
@@ -247,6 +247,12 @@ func (a *Arr) DeleteFiles(files []ContentFile) error {
 	for _, f := range files {
 		ids = append(ids, f.FileId)
 	}
+	defer func() {
+		// Delete files, or at least try
+		for _, f := range files {
+			f.Delete()
+		}
+	}()
 	var payload interface{}
 	switch a.Type {
 	case Sonarr:

pkg/arr/history.go

@@ -1,7 +1,7 @@
 package arr
 
 import (
-	"github.com/goccy/go-json"
+	"encoding/json"
 	"io"
 	"net/http"
 	gourl "net/url"

pkg/arr/import.go

@@ -1,8 +1,8 @@
 package arr
 
 import (
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
 	"io"
 	"net/http"
 	gourl "net/url"

pkg/arr/types.go

@@ -1,5 +1,7 @@
 package arr
 
+import "os"
+
 type Movie struct {
 	Title         string `json:"title"`
 	OriginalTitle string `json:"originalTitle"`
@@ -25,6 +27,12 @@ type ContentFile struct {
 	SeasonNumber int    `json:"seasonNumber"`
 }
 
+func (file *ContentFile) Delete() {
+	// This is useful for when sonarr bulk delete fails(this usually happens)
+	// and we need to delete the file manually
+	_ = os.Remove(file.Path) // nolint:errcheck
+}
+
 type Content struct {
 	Title string        `json:"title"`
 	Id    int           `json:"id"`

pkg/debrid/alldebrid/alldebrid.go

@@ -1,9 +1,8 @@
 package alldebrid
 
 import (
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
-	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
@@ -13,7 +12,6 @@ import (
 	"net/http"
 	gourl "net/url"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"sync"
 	"time"
@@ -23,13 +21,14 @@ type AllDebrid struct {
 	Name             string
 	Host             string `json:"host"`
 	APIKey           string
-	DownloadKeys     *xsync.MapOf[string, types.Account]
+	accounts         map[string]types.Account
 	DownloadUncached bool
 	client           *request.Client
 
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
 func New(dc config.Debrid) *AllDebrid {
@@ -46,25 +45,26 @@ func New(dc config.Debrid) *AllDebrid {
 		request.WithProxy(dc.Proxy),
 	)
 
-	accounts := xsync.NewMapOf[string, types.Account]()
+	accounts := make(map[string]types.Account)
 	for idx, key := range dc.DownloadAPIKeys {
 		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
+		accounts[id] = types.Account{
 			Name:  key,
 			ID:    id,
 			Token: key,
-		})
+		}
 	}
 	return &AllDebrid{
 		Name:             "alldebrid",
-		Host:             dc.Host,
+		Host:             "http://api.alldebrid.com/v4.1",
 		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
+		accounts:         accounts,
 		DownloadUncached: dc.DownloadUncached,
 		client:           client,
 		MountPath:        dc.Folder,
 		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
+		checkCached:      dc.CheckCached,
+		addSamples:       dc.AddSamples,
 	}
 }
 
@@ -122,7 +122,7 @@ func getAlldebridStatus(statusCode int) string {
 	}
 }
 
-func flattenFiles(files []MagnetFile, parentPath string, index *int) map[string]types.File {
+func (ad *AllDebrid) flattenFiles(torrentId string, files []MagnetFile, parentPath string, index *int) map[string]types.File {
 	result := make(map[string]types.File)
 
 	cfg := config.Get()
@@ -135,7 +135,7 @@ func flattenFiles(files []MagnetFile, parentPath string, index *int) map[string]
 
 		if f.Elements != nil {
 			// This is a folder, recurse into it
-			subFiles := flattenFiles(f.Elements, currentPath, index)
+			subFiles := ad.flattenFiles(torrentId, f.Elements, currentPath, index)
 			for k, v := range subFiles {
 				if _, ok := result[k]; ok {
 					// File already exists, use path as key
@@ -149,7 +149,7 @@ func flattenFiles(files []MagnetFile, parentPath string, index *int) map[string]
 			fileName := filepath.Base(f.Name)
 
 			// Skip sample files
-			if utils.IsSampleFile(f.Name) {
+			if !ad.addSamples && utils.IsSampleFile(f.Name) {
 				continue
 			}
 			if !cfg.IsAllowedFile(fileName) {
@@ -162,11 +162,12 @@ func flattenFiles(files []MagnetFile, parentPath string, index *int) map[string]
 
 			*index++
 			file := types.File{
-				Id:   strconv.Itoa(*index),
-				Name: fileName,
-				Size: f.Size,
-				Path: currentPath,
-				Link: f.Link,
+				TorrentId: torrentId,
+				Id:        strconv.Itoa(*index),
+				Name:      fileName,
+				Size:      f.Size,
+				Path:      currentPath,
+				Link:      f.Link,
 			}
 			result[file.Name] = file
 		}
@@ -175,6 +176,48 @@ func flattenFiles(files []MagnetFile, parentPath string, index *int) map[string]
 	return result
 }
 
+func (ad *AllDebrid) GetTorrent(torrentId string) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/magnet/status?id=%s", ad.Host, torrentId)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := ad.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var res TorrentInfoResponse
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		ad.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
+		return nil, err
+	}
+	data := res.Data.Magnets
+	status := getAlldebridStatus(data.StatusCode)
+	name := data.Filename
+	t := &types.Torrent{
+		Id:               strconv.Itoa(data.Id),
+		Name:             name,
+		Status:           status,
+		Filename:         name,
+		OriginalFilename: name,
+		Files:            make(map[string]types.File),
+		InfoHash:         data.Hash,
+		Debrid:           ad.Name,
+		MountPath:        ad.MountPath,
+		Added:            time.Unix(data.CompletionDate, 0).Format(time.RFC3339),
+	}
+	t.Bytes = data.Size
+	t.Seeders = data.Seeders
+	if status == "downloaded" {
+		t.Progress = 100
+		index := -1
+		files := ad.flattenFiles(t.Id, data.Files, "", &index)
+		t.Files = files
+	} else {
+		t.Progress = float64(data.Downloaded) / float64(data.Size) * 100
+		t.Speed = data.DownloadSpeed
+	}
+	return t, nil
+}
+
 func (ad *AllDebrid) UpdateTorrent(t *types.Torrent) error {
 	url := fmt.Sprintf("%s/magnet/status?id=%s", ad.Host, t.Id)
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
@@ -198,15 +241,17 @@ func (ad *AllDebrid) UpdateTorrent(t *types.Torrent) error {
 	t.Folder = name
 	t.MountPath = ad.MountPath
 	t.Debrid = ad.Name
+	t.Bytes = data.Size
+	t.Seeders = data.Seeders
+	t.Added = time.Unix(data.CompletionDate, 0).Format(time.RFC3339)
 	if status == "downloaded" {
-		t.Bytes = data.Size
-
-		t.Progress = float64((data.Downloaded / data.Size) * 100)
-		t.Speed = data.DownloadSpeed
-		t.Seeders = data.Seeders
+		t.Progress = 100
 		index := -1
-		files := flattenFiles(data.Files, "", &index)
+		files := ad.flattenFiles(t.Id, data.Files, "", &index)
 		t.Files = files
+	} else {
+		t.Progress = float64(data.Downloaded) / float64(data.Size) * 100
+		t.Speed = data.DownloadSpeed
 	}
 	return nil
 }
@@ -228,7 +273,7 @@ func (ad *AllDebrid) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types
 				}
 			}
 			break
-		} else if slices.Contains(ad.GetDownloadingStatus(), status) {
+		} else if utils.Contains(ad.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -262,16 +307,14 @@ func (ad *AllDebrid) GenerateDownloadLinks(t *types.Torrent) error {
 	for _, file := range t.Files {
 		go func(file types.File) {
 			defer wg.Done()
-			link, accountId, err := ad.GetDownloadLink(t, &file)
+			link, err := ad.GetDownloadLink(t, &file)
 			if err != nil {
 				errCh <- err
 				return
 			}
 			file.DownloadLink = link
-			file.Generated = time.Now()
-			file.AccountId = accountId
-			if link == "" {
-				errCh <- fmt.Errorf("error getting download links %w", err)
+			if link != nil {
+				errCh <- fmt.Errorf("download link is empty")
 				return
 			}
 			filesCh <- file
@@ -298,7 +341,7 @@ func (ad *AllDebrid) GenerateDownloadLinks(t *types.Torrent) error {
 	return nil
 }
 
-func (ad *AllDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (string, string, error) {
+func (ad *AllDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (*types.DownloadLink, error) {
 	url := fmt.Sprintf("%s/link/unlock", ad.Host)
 	query := gourl.Values{}
 	query.Add("link", file.Link)
@@ -306,21 +349,33 @@ func (ad *AllDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (string
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
 	resp, err := ad.client.MakeRequest(req)
 	if err != nil {
-		return "", "", err
+		return nil, err
 	}
 	var data DownloadLink
 	if err = json.Unmarshal(resp, &data); err != nil {
-		return "", "", err
+		return nil, err
+	}
+
+	if data.Error != nil {
+		return nil, fmt.Errorf("error getting download link: %s", data.Error.Message)
 	}
 	link := data.Data.Link
 	if link == "" {
-		return "", "", fmt.Errorf("error getting download links %s", data.Error.Message)
+		return nil, fmt.Errorf("download link is empty")
 	}
-	return link, "0", nil
+	return &types.DownloadLink{
+		Link:         file.Link,
+		DownloadLink: link,
+		Id:           data.Data.Id,
+		Size:         file.Size,
+		Filename:     file.Name,
+		Generated:    time.Now(),
+		AccountId:    "0",
+	}, nil
 }
 
 func (ad *AllDebrid) GetCheckCached() bool {
-	return ad.CheckCached
+	return ad.checkCached
 }
 
 func (ad *AllDebrid) GetTorrents() ([]*types.Torrent, error) {
@@ -349,13 +404,14 @@ func (ad *AllDebrid) GetTorrents() ([]*types.Torrent, error) {
 			InfoHash:         magnet.Hash,
 			Debrid:           ad.Name,
 			MountPath:        ad.MountPath,
+			Added:            time.Unix(magnet.CompletionDate, 0).Format(time.RFC3339),
 		})
 	}
 
 	return torrents, nil
 }
 
-func (ad *AllDebrid) GetDownloads() (map[string]types.DownloadLinks, error) {
+func (ad *AllDebrid) GetDownloads() (map[string]types.DownloadLink, error) {
 	return nil, nil
 }
 
@@ -381,3 +437,6 @@ func (ad *AllDebrid) DisableAccount(accountId string) {
 func (ad *AllDebrid) ResetActiveDownloadKeys() {
 
 }
+func (ad *AllDebrid) DeleteDownloadLink(linkId string) error {
+	return nil
+}

pkg/debrid/alldebrid/types.go

@@ -18,13 +18,13 @@ type magnetInfo struct {
 	Hash           string       `json:"hash"`
 	Status         string       `json:"status"`
 	StatusCode     int          `json:"statusCode"`
-	UploadDate     int          `json:"uploadDate"`
+	UploadDate     int64        `json:"uploadDate"`
 	Downloaded     int64        `json:"downloaded"`
 	Uploaded       int64        `json:"uploaded"`
 	DownloadSpeed  int64        `json:"downloadSpeed"`
 	UploadSpeed    int64        `json:"uploadSpeed"`
 	Seeders        int          `json:"seeders"`
-	CompletionDate int          `json:"completionDate"`
+	CompletionDate int64        `json:"completionDate"`
 	Type           string       `json:"type"`
 	Notified       bool         `json:"notified"`
 	Version        int          `json:"version"`

pkg/debrid/debrid/debrid.go

@@ -10,6 +10,7 @@ import (
 	"github.com/sirrobot01/decypharr/pkg/debrid/realdebrid"
 	"github.com/sirrobot01/decypharr/pkg/debrid/torbox"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"strings"
 )
 
 func createDebridClient(dc config.Debrid) types.Client {
@@ -38,49 +39,65 @@ func ProcessTorrent(d *Engine, magnet *utils.Magnet, a *arr.Arr, isSymlink, over
 		Files:    make(map[string]types.File),
 	}
 
-	errs := make([]error, 0)
+	errs := make([]error, 0, len(d.Clients))
+
+	// Override first, arr second, debrid third
+
+	if overrideDownloadUncached {
+		debridTorrent.DownloadUncached = true
+	} else if a.DownloadUncached != nil {
+		// Arr cached is set
+		debridTorrent.DownloadUncached = *a.DownloadUncached
+	} else {
+		debridTorrent.DownloadUncached = false
+	}
 
 	for index, db := range d.Clients {
 		logger := db.GetLogger()
-		logger.Info().Msgf("Processing debrid: %s", db.GetName())
+		logger.Info().Str("Debrid", db.GetName()).Str("Hash", debridTorrent.InfoHash).Msg("Processing torrent")
 
-		// Override first, arr second, debrid third
-
-		if overrideDownloadUncached {
-			debridTorrent.DownloadUncached = true
-		} else if a.DownloadUncached != nil {
-			// Arr cached is set
-			debridTorrent.DownloadUncached = *a.DownloadUncached
-		} else {
+		if !overrideDownloadUncached && a.DownloadUncached == nil {
 			debridTorrent.DownloadUncached = db.GetDownloadUncached()
 		}
 
-		logger.Info().Msgf("Torrent Hash: %s", debridTorrent.InfoHash)
-		if db.GetCheckCached() {
-			hash, exists := db.IsAvailable([]string{debridTorrent.InfoHash})[debridTorrent.InfoHash]
-			if !exists || !hash {
-				logger.Info().Msgf("Torrent: %s is not cached", debridTorrent.Name)
-				continue
-			} else {
-				logger.Info().Msgf("Torrent: %s is cached(or downloading)", debridTorrent.Name)
-			}
-		}
+		//if db.GetCheckCached() {
+		//	hash, exists := db.IsAvailable([]string{debridTorrent.InfoHash})[debridTorrent.InfoHash]
+		//	if !exists || !hash {
+		//		logger.Info().Msgf("Torrent: %s is not cached", debridTorrent.Name)
+		//		continue
+		//	} else {
+		//		logger.Info().Msgf("Torrent: %s is cached(or downloading)", debridTorrent.Name)
+		//	}
+		//}
 
 		dbt, err := db.SubmitMagnet(debridTorrent)
-		if dbt != nil {
-			dbt.Arr = a
-		}
 		if err != nil || dbt == nil || dbt.Id == "" {
 			errs = append(errs, err)
 			continue
 		}
-		logger.Info().Msgf("Torrent: %s(id=%s) submitted to %s", dbt.Name, dbt.Id, db.GetName())
+		dbt.Arr = a
+		logger.Info().Str("id", dbt.Id).Msgf("Torrent: %s submitted to %s", dbt.Name, db.GetName())
 		d.LastUsed = index
-		return db.CheckStatus(dbt, isSymlink)
+
+		torrent, err := db.CheckStatus(dbt, isSymlink)
+		if err != nil && torrent != nil && torrent.Id != "" {
+			// Delete the torrent if it was not downloaded
+			go func(id string) {
+				_ = db.DeleteTorrent(id)
+			}(torrent.Id)
+		}
+		return torrent, err
 	}
-	err := fmt.Errorf("failed to process torrent")
-	for _, e := range errs {
-		err = fmt.Errorf("%w\n%w", err, e)
+	if len(errs) == 0 {
+		return nil, fmt.Errorf("failed to process torrent: no clients available")
+	}
+	if len(errs) == 1 {
+		return nil, fmt.Errorf("failed to process torrent: %w", errs[0])
+	} else {
+		errStrings := make([]string, 0, len(errs))
+		for _, err := range errs {
+			errStrings = append(errStrings, err.Error())
+		}
+		return nil, fmt.Errorf("failed to process torrent: %s", strings.Join(errStrings, ", "))
 	}
-	return nil, err
 }

pkg/debrid/debrid/download_link.go

@@ -0,0 +1,236 @@
+package debrid
+
+import (
+	"errors"
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/request"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"sync"
+	"time"
+)
+
+type linkCache struct {
+	Id        string
+	link      string
+	accountId string
+	expiresAt time.Time
+}
+
+type downloadLinkCache struct {
+	data map[string]linkCache
+	mu   sync.Mutex
+}
+
+func newDownloadLinkCache() *downloadLinkCache {
+	return &downloadLinkCache{
+		data: make(map[string]linkCache),
+	}
+}
+
+func (c *downloadLinkCache) reset() {
+	c.mu.Lock()
+	c.data = make(map[string]linkCache)
+	c.mu.Unlock()
+}
+
+func (c *downloadLinkCache) Load(key string) (linkCache, bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	dl, ok := c.data[key]
+	return dl, ok
+}
+func (c *downloadLinkCache) Store(key string, value linkCache) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.data[key] = value
+}
+func (c *downloadLinkCache) Delete(key string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	delete(c.data, key)
+}
+
+type downloadLinkRequest struct {
+	result string
+	err    error
+	done   chan struct{}
+}
+
+func newDownloadLinkRequest() *downloadLinkRequest {
+	return &downloadLinkRequest{
+		done: make(chan struct{}),
+	}
+}
+
+func (r *downloadLinkRequest) Complete(result string, err error) {
+	r.result = result
+	r.err = err
+	close(r.done)
+}
+
+func (r *downloadLinkRequest) Wait() (string, error) {
+	<-r.done
+	return r.result, r.err
+}
+
+func (c *Cache) GetDownloadLink(torrentName, filename, fileLink string) (string, error) {
+	// Check link cache
+	if dl := c.checkDownloadLink(fileLink); dl != "" {
+		return dl, nil
+	}
+
+	if req, inFlight := c.downloadLinkRequests.Load(fileLink); inFlight {
+		// Wait for the other request to complete and use its result
+		result := req.(*downloadLinkRequest)
+		return result.Wait()
+	}
+
+	// Create a new request object
+	req := newDownloadLinkRequest()
+	c.downloadLinkRequests.Store(fileLink, req)
+
+	downloadLink, err := c.fetchDownloadLink(torrentName, filename, fileLink)
+
+	// Complete the request and remove it from the map
+	req.Complete(downloadLink, err)
+	c.downloadLinkRequests.Delete(fileLink)
+
+	return downloadLink, err
+}
+
+func (c *Cache) fetchDownloadLink(torrentName, filename, fileLink string) (string, error) {
+	ct := c.GetTorrentByName(torrentName)
+	if ct == nil {
+		return "", fmt.Errorf("torrent not found")
+	}
+	file, ok := ct.GetFile(filename)
+	if !ok {
+		return "", fmt.Errorf("file %s not found in torrent %s", filename, torrentName)
+	}
+
+	if file.Link == "" {
+		// file link is empty, refresh the torrent to get restricted links
+		ct = c.refreshTorrent(file.TorrentId) // Refresh the torrent from the debrid
+		if ct == nil {
+			return "", fmt.Errorf("failed to refresh torrent")
+		} else {
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return "", fmt.Errorf("file %s not found in refreshed torrent %s", filename, torrentName)
+			}
+		}
+	}
+
+	// If file.Link is still empty, return
+	if file.Link == "" {
+		// Try to reinsert the torrent?
+		newCt, err := c.reInsertTorrent(ct)
+		if err != nil {
+			return "", fmt.Errorf("failed to reinsert torrent. %w", err)
+		}
+		ct = newCt
+		file, ok = ct.GetFile(filename)
+		if !ok {
+			return "", fmt.Errorf("file %s not found in reinserted torrent %s", filename, torrentName)
+		}
+	}
+
+	c.logger.Trace().Msgf("Getting download link for %s(%s)", filename, file.Link)
+	downloadLink, err := c.client.GetDownloadLink(ct.Torrent, &file)
+	if err != nil {
+		if errors.Is(err, request.HosterUnavailableError) {
+			newCt, err := c.reInsertTorrent(ct)
+			if err != nil {
+				return "", fmt.Errorf("failed to reinsert torrent: %w", err)
+			}
+			ct = newCt
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return "", fmt.Errorf("file %s not found in reinserted torrent %s", filename, torrentName)
+			}
+			// Retry getting the download link
+			downloadLink, err = c.client.GetDownloadLink(ct.Torrent, &file)
+			if err != nil {
+				return "", err
+			}
+			if downloadLink == nil {
+				return "", fmt.Errorf("download link is empty for")
+			}
+			c.updateDownloadLink(downloadLink)
+			return "", nil
+		} else if errors.Is(err, request.TrafficExceededError) {
+			// This is likely a fair usage limit error
+			return "", err
+		} else {
+			return "", fmt.Errorf("failed to get download link: %w", err)
+		}
+	}
+	if downloadLink == nil {
+		return "", fmt.Errorf("download link is empty")
+	}
+	c.updateDownloadLink(downloadLink)
+	return downloadLink.DownloadLink, nil
+}
+
+func (c *Cache) GenerateDownloadLinks(t CachedTorrent) {
+	if err := c.client.GenerateDownloadLinks(t.Torrent); err != nil {
+		c.logger.Error().Err(err).Str("torrent", t.Name).Msg("Failed to generate download links")
+		return
+	}
+	for _, file := range t.GetFiles() {
+		if file.DownloadLink != nil {
+			c.updateDownloadLink(file.DownloadLink)
+		}
+	}
+	c.setTorrent(t, nil)
+}
+
+func (c *Cache) updateDownloadLink(dl *types.DownloadLink) {
+	c.downloadLinks.Store(dl.Link, linkCache{
+		Id:        dl.Id,
+		link:      dl.DownloadLink,
+		expiresAt: time.Now().Add(c.autoExpiresLinksAfterDuration),
+		accountId: dl.AccountId,
+	})
+}
+
+func (c *Cache) checkDownloadLink(link string) string {
+	if dl, ok := c.downloadLinks.Load(link); ok {
+		if dl.expiresAt.After(time.Now()) && !c.IsDownloadLinkInvalid(dl.link) {
+			return dl.link
+		}
+	}
+	return ""
+}
+
+func (c *Cache) MarkDownloadLinkAsInvalid(link, downloadLink, reason string) {
+	c.invalidDownloadLinks.Store(downloadLink, reason)
+	// Remove the download api key from active
+	if reason == "bandwidth_exceeded" {
+		if dl, ok := c.downloadLinks.Load(link); ok {
+			if dl.accountId != "" && dl.link == downloadLink {
+				c.client.DisableAccount(dl.accountId)
+			}
+		}
+	}
+	c.removeDownloadLink(link)
+}
+
+func (c *Cache) removeDownloadLink(link string) {
+	if dl, ok := c.downloadLinks.Load(link); ok {
+		// Delete dl from cache
+		c.downloadLinks.Delete(link)
+		// Delete dl from debrid
+		if dl.Id != "" {
+			_ = c.client.DeleteDownloadLink(dl.Id)
+		}
+	}
+}
+
+func (c *Cache) IsDownloadLinkInvalid(downloadLink string) bool {
+	if reason, ok := c.invalidDownloadLinks.Load(downloadLink); ok {
+		c.logger.Debug().Msgf("Download link %s is invalid: %s", downloadLink, reason)
+		return true
+	}
+	return false
+}

pkg/debrid/debrid/engine.go

@@ -3,12 +3,15 @@ package debrid
 import (
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"sync"
 )
 
 type Engine struct {
-	Clients  map[string]types.Client
-	Caches   map[string]*Cache
-	LastUsed string
+	Clients   map[string]types.Client
+	clientsMu sync.Mutex
+	Caches    map[string]*Cache
+	CacheMu   sync.Mutex
+	LastUsed  string
 }
 
 func NewEngine() *Engine {
@@ -37,17 +40,20 @@ func NewEngine() *Engine {
 	return d
 }
 
-func (d *Engine) Get() types.Client {
-	if d.LastUsed == "" {
-		for _, c := range d.Clients {
-			return c
-		}
-	}
-	return d.Clients[d.LastUsed]
+func (d *Engine) GetClient(name string) types.Client {
+	d.clientsMu.Lock()
+	defer d.clientsMu.Unlock()
+	return d.Clients[name]
 }
 
-func (d *Engine) GetByName(name string) types.Client {
-	return d.Clients[name]
+func (d *Engine) Reset() {
+	d.clientsMu.Lock()
+	d.Clients = make(map[string]types.Client)
+	d.clientsMu.Unlock()
+
+	d.CacheMu.Lock()
+	d.Caches = make(map[string]*Cache)
+	d.CacheMu.Unlock()
 }
 
 func (d *Engine) GetDebrids() map[string]types.Client {

pkg/debrid/debrid/misc.go

@@ -0,0 +1,27 @@
+package debrid
+
+import (
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"sort"
+)
+
+// MergeFiles merges the files from multiple torrents into a single map.
+// It uses the file name as the key and the file object as the value.
+// This is useful for deduplicating files across multiple torrents.
+// The order of the torrents is determined by the AddedOn time, with the earliest added torrent first.
+// If a file with the same name exists in multiple torrents, the last one will be used.
+func mergeFiles(torrents ...CachedTorrent) map[string]types.File {
+	merged := make(map[string]types.File)
+
+	// order torrents by added time
+	sort.Slice(torrents, func(i, j int) bool {
+		return torrents[i].AddedOn.Before(torrents[j].AddedOn)
+	})
+
+	for _, torrent := range torrents {
+		for _, file := range torrent.GetFiles() {
+			merged[file.Name] = file
+		}
+	}
+	return merged
+}

pkg/debrid/debrid/refresh.go

@@ -1,21 +1,19 @@
 package debrid
 
 import (
+	"context"
 	"fmt"
-	"github.com/sirrobot01/decypharr/internal/config"
-	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
 	"io"
 	"net/http"
 	"os"
-	"slices"
-	"sort"
 	"strings"
 	"sync"
 	"time"
 )
 
 type fileInfo struct {
+	id      string
 	name    string
 	size    int64
 	mode    os.FileMode
@@ -28,61 +26,36 @@ func (fi *fileInfo) Size() int64        { return fi.size }
 func (fi *fileInfo) Mode() os.FileMode  { return fi.mode }
 func (fi *fileInfo) ModTime() time.Time { return fi.modTime }
 func (fi *fileInfo) IsDir() bool        { return fi.isDir }
+func (fi *fileInfo) ID() string         { return fi.id }
 func (fi *fileInfo) Sys() interface{}   { return nil }
 
-func (c *Cache) refreshListings() {
-	if c.listingRefreshMu.TryLock() {
-		defer c.listingRefreshMu.Unlock()
-	} else {
-		return
-	}
-	// COpy the torrents to a string|time map
-	torrentsTime := make(map[string]time.Time, c.torrents.Size())
-	torrents := make([]string, 0, c.torrents.Size())
-	c.torrentsNames.Range(func(key string, value *CachedTorrent) bool {
-		torrentsTime[key] = value.AddedOn
-		torrents = append(torrents, key)
-		return true
-	})
+func (c *Cache) RefreshListings(refreshRclone bool) {
+	// Copy the torrents to a string|time map
+	c.torrents.refreshListing() // refresh torrent listings
 
-	// Sort the torrents by name
-	sort.Strings(torrents)
-
-	files := make([]os.FileInfo, 0, len(torrents))
-	for _, t := range torrents {
-		files = append(files, &fileInfo{
-			name:    t,
-			size:    0,
-			mode:    0755 | os.ModeDir,
-			modTime: torrentsTime[t],
-			isDir:   true,
-		})
-	}
-	// Atomic store of the complete ready-to-use slice
-	c.listings.Store(files)
-	_ = c.refreshXml()
-	if err := c.RefreshRclone(); err != nil {
-		c.logger.Trace().Err(err).Msg("Failed to refresh rclone") // silent error
+	if refreshRclone {
+		if err := c.refreshRclone(); err != nil {
+			c.logger.Error().Err(err).Msg("Failed to refresh rclone") // silent error
+		}
 	}
 }
 
-func (c *Cache) refreshTorrents() {
-	if c.torrentsRefreshMu.TryLock() {
-		defer c.torrentsRefreshMu.Unlock()
-	} else {
+func (c *Cache) refreshTorrents(ctx context.Context) {
+	select {
+	case <-ctx.Done():
+		return
+	default:
+	}
+
+	if !c.torrentsRefreshMu.TryLock() {
 		return
 	}
-	// Create a copy of the current torrents to avoid concurrent issues
-	torrents := make(map[string]string, c.torrents.Size()) // a mpa of id and name
-	c.torrents.Range(func(key string, t *CachedTorrent) bool {
-		torrents[t.Id] = t.Name
-		return true
-	})
+	defer c.torrentsRefreshMu.Unlock()
 
-	// Get new torrents from the debrid service
+	// Get all torrents from the debrid service
 	debTorrents, err := c.client.GetTorrents()
 	if err != nil {
-		c.logger.Debug().Err(err).Msg("Failed to get torrents")
+		c.logger.Error().Err(err).Msg("Failed to get torrents")
 		return
 	}
 
@@ -91,159 +64,204 @@ func (c *Cache) refreshTorrents() {
 		return
 	}
 
-	// Get the newly added torrents only
-	_newTorrents := make([]*types.Torrent, 0)
-	idStore := make(map[string]struct{}, len(debTorrents))
+	currentTorrentIds := make(map[string]struct{}, len(debTorrents))
 	for _, t := range debTorrents {
-		idStore[t.Id] = struct{}{}
-		if _, ok := torrents[t.Id]; !ok {
-			_newTorrents = append(_newTorrents, t)
-		}
+		currentTorrentIds[t.Id] = struct{}{}
 	}
 
-	// Check for deleted torrents
+	// Let's implement deleting torrents removed from debrid
 	deletedTorrents := make([]string, 0)
-	for id := range torrents {
-		if _, ok := idStore[id]; !ok {
+	cachedTorrents := c.torrents.getIdMaps()
+	for id := range cachedTorrents {
+		if _, exists := currentTorrentIds[id]; !exists {
 			deletedTorrents = append(deletedTorrents, id)
 		}
 	}
-	newTorrents := make([]*types.Torrent, 0)
-	for _, t := range _newTorrents {
-		if !slices.Contains(deletedTorrents, t.Id) {
-			newTorrents = append(newTorrents, t)
-		}
-	}
 
 	if len(deletedTorrents) > 0 {
-		c.DeleteTorrents(deletedTorrents)
+		go c.validateAndDeleteTorrents(deletedTorrents)
+	}
+
+	newTorrents := make([]*types.Torrent, 0)
+	for _, t := range debTorrents {
+		if _, exists := cachedTorrents[t.Id]; !exists {
+			newTorrents = append(newTorrents, t)
+		}
 	}
 
 	if len(newTorrents) == 0 {
 		return
 	}
-	c.logger.Info().Msgf("Found %d new torrents", len(newTorrents))
+
+	c.logger.Trace().Msgf("Found %d new torrents", len(newTorrents))
 
 	workChan := make(chan *types.Torrent, min(100, len(newTorrents)))
 	errChan := make(chan error, len(newTorrents))
 	var wg sync.WaitGroup
+	counter := 0
 
 	for i := 0; i < c.workers; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			for t := range workChan {
-				select {
-				case <-c.ctx.Done():
-					return
-				default:
-				}
-				if err := c.ProcessTorrent(t, true); err != nil {
-					c.logger.Debug().Err(err).Msgf("Failed to process new torrent %s", t.Id)
+				if err := c.ProcessTorrent(t); err != nil {
+					c.logger.Error().Err(err).Msgf("Failed to process new torrent %s", t.Id)
 					errChan <- err
 				}
+				counter++
 			}
 		}()
 	}
 
 	for _, t := range newTorrents {
-		select {
-		case <-c.ctx.Done():
-			break
-		default:
-			workChan <- t
-		}
+		workChan <- t
 	}
 	close(workChan)
 	wg.Wait()
 
-	c.logger.Debug().Msgf("Processed %d new torrents", len(newTorrents))
+	c.listingDebouncer.Call(false)
+
+	c.logger.Debug().Msgf("Processed %d new torrents", counter)
 }
 
-func (c *Cache) RefreshRclone() error {
-	client := request.Default()
-	cfg := config.Get().WebDav
+func (c *Cache) refreshRclone() error {
+	cfg := c.config
 
 	if cfg.RcUrl == "" {
 		return nil
 	}
+
+	if cfg.RcUrl == "" {
+		return nil
+	}
+
+	client := &http.Client{
+		Timeout: 10 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        10,
+			IdleConnTimeout:     30 * time.Second,
+			DisableCompression:  false,
+			MaxIdleConnsPerHost: 5,
+		},
+	}
 	// Create form data
-	data := "dir=__all__&dir2=torrents"
+	data := ""
+	dirs := strings.FieldsFunc(cfg.RcRefreshDirs, func(r rune) bool {
+		return r == ',' || r == '&'
+	})
+	if len(dirs) == 0 {
+		data = "dir=__all__"
+	} else {
+		for index, dir := range dirs {
+			if dir != "" {
+				if index == 0 {
+					data += "dir=" + dir
+				} else {
+					data += "&dir" + fmt.Sprint(index+1) + "=" + dir
+				}
+			}
+		}
+	}
 
-	// Create a POST request with form URL-encoded content
-	forgetReq, err := http.NewRequest("POST", fmt.Sprintf("%s/vfs/forget", cfg.RcUrl), strings.NewReader(data))
-	if err != nil {
+	sendRequest := func(endpoint string) error {
+		req, err := http.NewRequest("POST", fmt.Sprintf("%s/%s", cfg.RcUrl, endpoint), strings.NewReader(data))
+		if err != nil {
+			return err
+		}
+
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+		if cfg.RcUser != "" && cfg.RcPass != "" {
+			req.SetBasicAuth(cfg.RcUser, cfg.RcPass)
+		}
+		resp, err := client.Do(req)
+		if err != nil {
+			return err
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != 200 {
+			body, _ := io.ReadAll(io.LimitReader(resp.Body, 1024))
+			return fmt.Errorf("failed to perform %s: %s - %s", endpoint, resp.Status, string(body))
+		}
+
+		_, _ = io.Copy(io.Discard, resp.Body)
+		return nil
+	}
+
+	if err := sendRequest("vfs/forget"); err != nil {
 		return err
 	}
-	if cfg.RcUser != "" && cfg.RcPass != "" {
-		forgetReq.SetBasicAuth(cfg.RcUser, cfg.RcPass)
-	}
-
-	// Set the appropriate content type for form data
-	forgetReq.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-
-	// Send the request
-	forgetResp, err := client.Do(forgetReq)
-	if err != nil {
+	if err := sendRequest("vfs/refresh"); err != nil {
 		return err
 	}
-	defer forgetResp.Body.Close()
 
-	if forgetResp.StatusCode != 200 {
-		body, _ := io.ReadAll(forgetResp.Body)
-		return fmt.Errorf("failed to forget rclone: %s - %s", forgetResp.Status, string(body))
-	}
 	return nil
 }
 
-func (c *Cache) refreshTorrent(t *CachedTorrent) *CachedTorrent {
-	_torrent := t.Torrent
-	err := c.client.UpdateTorrent(_torrent)
+func (c *Cache) refreshTorrent(torrentId string) *CachedTorrent {
+
+	if torrentId == "" {
+		c.logger.Error().Msg("Torrent ID is empty")
+		return nil
+	}
+
+	torrent, err := c.client.GetTorrent(torrentId)
 	if err != nil {
-		c.logger.Debug().Msgf("Failed to get torrent files for %s: %v", t.Id, err)
+		c.logger.Error().Err(err).Msgf("Failed to get torrent %s", torrentId)
 		return nil
 	}
-	if len(t.Files) == 0 {
-		return nil
-	}
-	addedOn, err := time.Parse(time.RFC3339, _torrent.Added)
+	addedOn, err := time.Parse(time.RFC3339, torrent.Added)
 	if err != nil {
 		addedOn = time.Now()
 	}
-	ct := &CachedTorrent{
-		Torrent:    _torrent,
+	ct := CachedTorrent{
+		Torrent:    torrent,
 		AddedOn:    addedOn,
-		IsComplete: len(t.Files) > 0,
+		IsComplete: len(torrent.Files) > 0,
 	}
-	c.setTorrent(ct)
+	c.setTorrent(ct, func(torrent CachedTorrent) {
+		go c.listingDebouncer.Call(true)
+	})
 
-	return ct
+	return &ct
 }
 
-func (c *Cache) refreshDownloadLinks() {
-	if c.downloadLinksRefreshMu.TryLock() {
-		defer c.downloadLinksRefreshMu.Unlock()
-	} else {
+func (c *Cache) refreshDownloadLinks(ctx context.Context) {
+
+	select {
+	case <-ctx.Done():
 		return
+	default:
 	}
 
+	if !c.downloadLinksRefreshMu.TryLock() {
+		return
+	}
+	defer c.downloadLinksRefreshMu.Unlock()
+
 	downloadLinks, err := c.client.GetDownloads()
+
 	if err != nil {
-		c.logger.Debug().Err(err).Msg("Failed to get download links")
+		c.logger.Error().Err(err).Msg("Failed to get download links")
+		return
 	}
 	for k, v := range downloadLinks {
 		// if link is generated in the last 24 hours, add it to cache
 		timeSince := time.Since(v.Generated)
-		if timeSince < c.autoExpiresLinksAfter {
-			c.downloadLinks.Store(k, downloadLinkCache{
-				Link:      v.DownloadLink,
-				ExpiresAt: v.Generated.Add(c.autoExpiresLinksAfter - timeSince),
+		if timeSince < c.autoExpiresLinksAfterDuration {
+			c.downloadLinks.Store(k, linkCache{
+				Id:        v.Id,
+				accountId: v.AccountId,
+				link:      v.DownloadLink,
+				expiresAt: v.Generated.Add(c.autoExpiresLinksAfterDuration - timeSince),
 			})
 		} else {
 			c.downloadLinks.Delete(k)
 		}
 	}
 
-	c.logger.Debug().Msgf("Refreshed %d download links", len(downloadLinks))
+	c.logger.Trace().Msgf("Refreshed %d download links", len(downloadLinks))
 
 }

pkg/debrid/debrid/repair.go

@@ -1,168 +1,257 @@
 package debrid
 
 import (
+	"context"
 	"errors"
 	"fmt"
-	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"slices"
+	"sync"
 	"time"
 )
 
-func (c *Cache) IsTorrentBroken(t *CachedTorrent, filenames []string) bool {
-	// Check torrent files
+type reInsertRequest struct {
+	result *CachedTorrent
+	err    error
+	done   chan struct{}
+}
 
-	isBroken := false
+func newReInsertRequest() *reInsertRequest {
+	return &reInsertRequest{
+		done: make(chan struct{}),
+	}
+}
+
+func (r *reInsertRequest) Complete(result *CachedTorrent, err error) {
+	r.result = result
+	r.err = err
+	close(r.done)
+}
+
+func (r *reInsertRequest) Wait() (*CachedTorrent, error) {
+	<-r.done
+	return r.result, r.err
+}
+
+func (c *Cache) markAsFailedToReinsert(torrentId string) {
+	c.failedToReinsert.Store(torrentId, struct{}{})
+
+	// Remove the torrent from the directory if it has failed to reinsert, max retries are hardcoded to 5
+	if torrent, ok := c.torrents.getByID(torrentId); ok {
+		torrent.Bad = true
+		c.setTorrent(torrent, func(t CachedTorrent) {
+			c.RefreshListings(false)
+		})
+	}
+}
+
+func (c *Cache) markAsSuccessfullyReinserted(torrentId string) {
+	if _, ok := c.failedToReinsert.Load(torrentId); !ok {
+		return
+	}
+	c.failedToReinsert.Delete(torrentId)
+	if torrent, ok := c.torrents.getByID(torrentId); ok {
+		torrent.Bad = false
+		c.setTorrent(torrent, func(torrent CachedTorrent) {
+			c.RefreshListings(false)
+		})
+	}
+}
+
+func (c *Cache) GetBrokenFiles(t *CachedTorrent, filenames []string) []string {
 	files := make(map[string]types.File)
+	brokenFiles := make([]string, 0)
 	if len(filenames) > 0 {
 		for name, f := range t.Files {
-			if slices.Contains(filenames, name) {
+			if utils.Contains(filenames, name) {
 				files[name] = f
 			}
 		}
 	} else {
 		files = t.Files
 	}
-
-	// Check empty links
 	for _, f := range files {
 		// Check if file is missing
 		if f.Link == "" {
 			// refresh torrent and then break
-			t = c.refreshTorrent(t)
-			break
+			if newT := c.refreshTorrent(f.TorrentId); newT != nil {
+				t = newT
+			} else {
+				c.logger.Error().Str("torrentId", t.Torrent.Id).Msg("Failed to refresh torrent")
+				return filenames // Return original filenames if refresh fails(torrent is somehow botched)
+			}
 		}
 	}
 
+	if t.Torrent == nil {
+		c.logger.Error().Str("torrentId", t.Torrent.Id).Msg("Failed to refresh torrent")
+		return filenames // Return original filenames if refresh fails(torrent is somehow botched)
+	}
+
 	files = t.Files
 
 	for _, f := range files {
 		// Check if file link is still missing
 		if f.Link == "" {
-			isBroken = true
-			break
+			brokenFiles = append(brokenFiles, f.Name)
 		} else {
 			// Check if file.Link not in the downloadLink Cache
 			if err := c.client.CheckLink(f.Link); err != nil {
 				if errors.Is(err, request.HosterUnavailableError) {
-					isBroken = true
-					break
+					brokenFiles = append(brokenFiles, f.Name)
 				}
 			}
 		}
 	}
-	return isBroken
+
+	// Try to reinsert the torrent if it's broken
+	if len(brokenFiles) > 0 && t.Torrent != nil {
+		// Check if the torrent is already in progress
+		if _, err := c.reInsertTorrent(t); err != nil {
+			c.logger.Error().Err(err).Str("torrentId", t.Torrent.Id).Msg("Failed to reinsert torrent")
+			return brokenFiles // Return broken files if reinsert fails
+		}
+		return nil // Return nil if the torrent was successfully reinserted
+	}
+
+	return brokenFiles
 }
 
-func (c *Cache) repairWorker() {
-	// This watches a channel for torrents to repair
-	for req := range c.repairChan {
-		torrentId := req.TorrentID
-		if _, inProgress := c.repairsInProgress.Load(torrentId); inProgress {
-			c.logger.Debug().Str("torrentId", torrentId).Msg("Skipping duplicate repair request")
-			continue
-		}
+func (c *Cache) repairWorker(ctx context.Context) {
+	// This watches a channel for torrents to repair and can be cancelled via context
+	for {
+		select {
+		case <-ctx.Done():
+			return
 
-		// Mark as in progress
-		c.repairsInProgress.Store(torrentId, struct{}{})
-		c.logger.Debug().Str("torrentId", req.TorrentID).Msg("Received repair request")
+		case req, ok := <-c.repairChan:
+			// Channel was closed
+			if !ok {
+				c.logger.Debug().Msg("Repair channel closed, shutting down worker")
+				return
+			}
 
-		// Get the torrent from the cache
-		cachedTorrent, ok := c.torrents.Load(torrentId)
-		if !ok || cachedTorrent == nil {
-			c.logger.Warn().Str("torrentId", torrentId).Msg("Torrent not found in cache")
-			continue
-		}
+			torrentId := req.TorrentID
+			c.logger.Debug().Str("torrentId", req.TorrentID).Msg("Received repair request")
 
-		switch req.Type {
-		case RepairTypeReinsert:
-			c.logger.Debug().Str("torrentId", torrentId).Msg("Reinserting torrent")
-			var err error
-			cachedTorrent, err = c.reInsertTorrent(cachedTorrent.Torrent)
-			if err != nil {
-				c.logger.Error().Err(err).Str("torrentId", cachedTorrent.Id).Msg("Failed to reinsert torrent")
+			// Get the torrent from the cache
+			cachedTorrent := c.GetTorrent(torrentId)
+			if cachedTorrent == nil {
+				c.logger.Warn().Str("torrentId", torrentId).Msg("Torrent not found in cache")
 				continue
 			}
-		case RepairTypeDelete:
-			c.logger.Debug().Str("torrentId", torrentId).Msg("Deleting torrent")
-			if err := c.DeleteTorrent(torrentId); err != nil {
-				c.logger.Error().Err(err).Str("torrentId", torrentId).Msg("Failed to delete torrent")
-				continue
+
+			switch req.Type {
+			case RepairTypeReinsert:
+				c.logger.Debug().Str("torrentId", torrentId).Msg("Reinserting torrent")
+				if _, err := c.reInsertTorrent(cachedTorrent); err != nil {
+					c.logger.Error().Err(err).Str("torrentId", cachedTorrent.Id).Msg("Failed to reinsert torrent")
+					continue
+				}
+			case RepairTypeDelete:
+				c.logger.Debug().Str("torrentId", torrentId).Msg("Deleting torrent")
+				if err := c.DeleteTorrent(torrentId); err != nil {
+					c.logger.Error().Err(err).Str("torrentId", torrentId).Msg("Failed to delete torrent")
+					continue
+				}
 			}
 		}
-		c.repairsInProgress.Delete(torrentId)
 	}
 }
 
-func (c *Cache) reInsertTorrent(torrent *types.Torrent) (*CachedTorrent, error) {
+func (c *Cache) reInsertTorrent(ct *CachedTorrent) (*CachedTorrent, error) {
 	// Check if Magnet is not empty, if empty, reconstruct the magnet
-	if _, ok := c.repairsInProgress.Load(torrent.Id); ok {
-		return nil, fmt.Errorf("repair already in progress for torrent %s", torrent.Id)
+	torrent := ct.Torrent
+	oldID := torrent.Id // Store the old ID
+	if _, ok := c.failedToReinsert.Load(oldID); ok {
+		return ct, fmt.Errorf("can't retry re-insert for %s", torrent.Id)
 	}
-
-	if torrent.Magnet == nil {
-		torrent.Magnet = utils.ConstructMagnet(torrent.InfoHash, torrent.Name)
+	if reqI, inFlight := c.repairRequest.Load(oldID); inFlight {
+		req := reqI.(*reInsertRequest)
+		c.logger.Debug().Msgf("Waiting for existing reinsert request to complete for torrent %s", oldID)
+		return req.Wait()
 	}
+	req := newReInsertRequest()
+	c.repairRequest.Store(oldID, req)
 
-	oldID := torrent.Id
+	// Make sure we clean up even if there's a panic
 	defer func() {
-		err := c.DeleteTorrent(oldID)
-		if err != nil {
-			c.logger.Error().Err(err).Str("torrentId", oldID).Msg("Failed to delete old torrent")
-		}
+		c.repairRequest.Delete(oldID)
 	}()
 
 	// Submit the magnet to the debrid service
-	torrent.Id = ""
+	newTorrent := &types.Torrent{
+		Name:     torrent.Name,
+		Magnet:   utils.ConstructMagnet(torrent.InfoHash, torrent.Name),
+		InfoHash: torrent.InfoHash,
+		Size:     torrent.Size,
+		Files:    make(map[string]types.File),
+		Arr:      torrent.Arr,
+	}
 	var err error
-	torrent, err = c.client.SubmitMagnet(torrent)
+	newTorrent, err = c.client.SubmitMagnet(newTorrent)
 	if err != nil {
+		c.markAsFailedToReinsert(oldID)
 		// Remove the old torrent from the cache and debrid service
-		return nil, fmt.Errorf("failed to submit magnet: %w", err)
+		return ct, fmt.Errorf("failed to submit magnet: %w", err)
 	}
 
 	// Check if the torrent was submitted
-	if torrent == nil || torrent.Id == "" {
-		return nil, fmt.Errorf("failed to submit magnet: empty torrent")
+	if newTorrent == nil || newTorrent.Id == "" {
+		c.markAsFailedToReinsert(oldID)
+		return ct, fmt.Errorf("failed to submit magnet: empty torrent")
 	}
-	torrent.DownloadUncached = false // Set to false, avoid re-downloading
-	torrent, err = c.client.CheckStatus(torrent, true)
-	if err != nil && torrent != nil {
-		// Torrent is likely in progress
-		_ = c.DeleteTorrent(torrent.Id)
-
-		return nil, fmt.Errorf("failed to check status: %w", err)
-	}
-
-	if torrent == nil {
-		return nil, fmt.Errorf("failed to check status: empty torrent")
+	newTorrent.DownloadUncached = false // Set to false, avoid re-downloading
+	newTorrent, err = c.client.CheckStatus(newTorrent, true)
+	if err != nil {
+		if newTorrent != nil && newTorrent.Id != "" {
+			// Delete the torrent if it was not downloaded
+			_ = c.client.DeleteTorrent(newTorrent.Id)
+		}
+		c.markAsFailedToReinsert(oldID)
+		return ct, err
 	}
 
 	// Update the torrent in the cache
-	addedOn, err := time.Parse(time.RFC3339, torrent.Added)
-	for _, f := range torrent.Files {
-		if f.Link == "" {
-			// Delete the new torrent
-			_ = c.DeleteTorrent(torrent.Id)
-			return nil, fmt.Errorf("failed to reinsert torrent: empty link")
-		}
-	}
+	addedOn, err := time.Parse(time.RFC3339, newTorrent.Added)
 	if err != nil {
 		addedOn = time.Now()
 	}
-	ct := &CachedTorrent{
-		Torrent:    torrent,
-		IsComplete: len(torrent.Files) > 0,
-		AddedOn:    addedOn,
+	for _, f := range newTorrent.GetFiles() {
+		if f.Link == "" {
+			c.markAsFailedToReinsert(oldID)
+			return ct, fmt.Errorf("failed to reinsert torrent: empty link")
+		}
 	}
-	c.setTorrent(ct)
-	c.refreshListings()
+	// Set torrent to newTorrent
+	newCt := CachedTorrent{
+		Torrent:    newTorrent,
+		AddedOn:    addedOn,
+		IsComplete: len(newTorrent.Files) > 0,
+	}
+	c.setTorrent(newCt, func(torrent CachedTorrent) {
+		c.RefreshListings(true)
+	})
+
+	ct = &newCt // Update ct to point to the new torrent
+
+	// We can safely delete the old torrent here
+	if oldID != "" {
+		if err := c.DeleteTorrent(oldID); err != nil {
+			return ct, fmt.Errorf("failed to delete old torrent: %w", err)
+		}
+	}
+
+	req.Complete(ct, err)
+	c.markAsSuccessfullyReinserted(oldID)
+
+	c.logger.Debug().Str("torrentId", torrent.Id).Msg("Torrent successfully reinserted")
+
 	return ct, nil
 }
 
 func (c *Cache) resetInvalidLinks() {
-	c.invalidDownloadLinks = xsync.NewMapOf[string, string]()
+	c.invalidDownloadLinks = sync.Map{}
 	c.client.ResetActiveDownloadKeys() // Reset the active download keys
 }

pkg/debrid/debrid/torrent.go

@@ -0,0 +1,298 @@
+package debrid
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+const (
+	filterByInclude string = "include"
+	filterByExclude string = "exclude"
+
+	filterByStartsWith    string = "starts_with"
+	filterByEndsWith      string = "ends_with"
+	filterByNotStartsWith string = "not_starts_with"
+	filterByNotEndsWith   string = "not_ends_with"
+
+	filterByRegex    string = "regex"
+	filterByNotRegex string = "not_regex"
+
+	filterByExactMatch    string = "exact_match"
+	filterByNotExactMatch string = "not_exact_match"
+
+	filterBySizeGT string = "size_gt"
+	filterBySizeLT string = "size_lt"
+
+	filterBLastAdded string = "last_added"
+)
+
+type directoryFilter struct {
+	filterType    string
+	value         string
+	regex         *regexp.Regexp // only for regex/not_regex
+	sizeThreshold int64          // only for size_gt/size_lt
+	ageThreshold  time.Duration  // only for last_added
+}
+
+type torrentCache struct {
+	mu                 sync.Mutex
+	byID               map[string]CachedTorrent
+	byName             map[string]CachedTorrent
+	listing            atomic.Value
+	folderListing      map[string][]os.FileInfo
+	folderListingMu    sync.RWMutex
+	directoriesFilters map[string][]directoryFilter
+	sortNeeded         atomic.Bool
+}
+
+type sortableFile struct {
+	id      string
+	name    string
+	modTime time.Time
+	size    int64
+	bad     bool
+}
+
+func newTorrentCache(dirFilters map[string][]directoryFilter) *torrentCache {
+
+	tc := &torrentCache{
+		byID:               make(map[string]CachedTorrent),
+		byName:             make(map[string]CachedTorrent),
+		folderListing:      make(map[string][]os.FileInfo),
+		directoriesFilters: dirFilters,
+	}
+
+	tc.sortNeeded.Store(false)
+	tc.listing.Store(make([]os.FileInfo, 0))
+	return tc
+}
+
+func (tc *torrentCache) reset() {
+	tc.mu.Lock()
+	tc.byID = make(map[string]CachedTorrent)
+	tc.byName = make(map[string]CachedTorrent)
+	tc.mu.Unlock()
+
+	// reset the sorted listing
+	tc.sortNeeded.Store(false)
+	tc.listing.Store(make([]os.FileInfo, 0))
+
+	// reset any per-folder views
+	tc.folderListingMu.Lock()
+	tc.folderListing = make(map[string][]os.FileInfo)
+	tc.folderListingMu.Unlock()
+}
+
+func (tc *torrentCache) getByID(id string) (CachedTorrent, bool) {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	torrent, exists := tc.byID[id]
+	return torrent, exists
+}
+
+func (tc *torrentCache) getByName(name string) (CachedTorrent, bool) {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	torrent, exists := tc.byName[name]
+	return torrent, exists
+}
+
+func (tc *torrentCache) set(name string, torrent, newTorrent CachedTorrent) {
+	tc.mu.Lock()
+	// Set the id first
+	tc.byID[newTorrent.Id] = torrent // This is the unadulterated torrent
+	tc.byName[name] = newTorrent     // This is likely the modified torrent
+	tc.mu.Unlock()
+	tc.sortNeeded.Store(true)
+}
+
+func (tc *torrentCache) getListing() []os.FileInfo {
+	// Fast path: if we have a sorted list and no changes since last sort
+	if !tc.sortNeeded.Load() {
+		return tc.listing.Load().([]os.FileInfo)
+	}
+
+	// Slow path: need to sort
+	tc.refreshListing()
+	return tc.listing.Load().([]os.FileInfo)
+}
+
+func (tc *torrentCache) getFolderListing(folderName string) []os.FileInfo {
+	tc.folderListingMu.RLock()
+	defer tc.folderListingMu.RUnlock()
+	if folderName == "" {
+		return tc.getListing()
+	}
+	if folder, ok := tc.folderListing[folderName]; ok {
+		return folder
+	}
+	// If folder not found, return empty slice
+	return []os.FileInfo{}
+}
+
+func (tc *torrentCache) refreshListing() {
+
+	tc.mu.Lock()
+	all := make([]sortableFile, 0, len(tc.byName))
+	for name, t := range tc.byName {
+		all = append(all, sortableFile{t.Id, name, t.AddedOn, t.Bytes, t.Bad})
+	}
+	tc.sortNeeded.Store(false)
+	tc.mu.Unlock()
+
+	sort.Slice(all, func(i, j int) bool {
+		if all[i].name != all[j].name {
+			return all[i].name < all[j].name
+		}
+		return all[i].modTime.Before(all[j].modTime)
+	})
+
+	wg := sync.WaitGroup{}
+
+	wg.Add(1) // for all listing
+	go func() {
+		listing := make([]os.FileInfo, len(all))
+		for i, sf := range all {
+			listing[i] = &fileInfo{sf.id, sf.name, sf.size, 0755 | os.ModeDir, sf.modTime, true}
+		}
+		tc.listing.Store(listing)
+	}()
+	wg.Done()
+
+	wg.Add(1)
+	// For __bad__
+	go func() {
+		listing := make([]os.FileInfo, 0)
+		for _, sf := range all {
+			if sf.bad {
+				listing = append(listing, &fileInfo{
+					id:      sf.id,
+					name:    fmt.Sprintf("%s || %s", sf.name, sf.id),
+					size:    sf.size,
+					mode:    0755 | os.ModeDir,
+					modTime: sf.modTime,
+					isDir:   true,
+				})
+			}
+		}
+		tc.folderListingMu.Lock()
+		if len(listing) > 0 {
+			tc.folderListing["__bad__"] = listing
+		} else {
+			delete(tc.folderListing, "__bad__")
+		}
+		tc.folderListingMu.Unlock()
+	}()
+	wg.Done()
+
+	now := time.Now()
+	wg.Add(len(tc.directoriesFilters)) // for each directory filter
+	for dir, filters := range tc.directoriesFilters {
+		go func(dir string, filters []directoryFilter) {
+			defer wg.Done()
+			var matched []os.FileInfo
+			for _, sf := range all {
+				if tc.torrentMatchDirectory(filters, sf, now) {
+					matched = append(matched, &fileInfo{
+						id:   sf.id,
+						name: sf.name, size: sf.size,
+						mode: 0755 | os.ModeDir, modTime: sf.modTime, isDir: true,
+					})
+				}
+			}
+
+			tc.folderListingMu.Lock()
+			if len(matched) > 0 {
+				tc.folderListing[dir] = matched
+			} else {
+				delete(tc.folderListing, dir)
+			}
+			tc.folderListingMu.Unlock()
+		}(dir, filters)
+	}
+
+	wg.Wait()
+}
+
+func (tc *torrentCache) torrentMatchDirectory(filters []directoryFilter, file sortableFile, now time.Time) bool {
+
+	torrentName := strings.ToLower(file.name)
+	for _, filter := range filters {
+		matched := false
+
+		switch filter.filterType {
+		case filterByInclude:
+			matched = strings.Contains(torrentName, filter.value)
+		case filterByStartsWith:
+			matched = strings.HasPrefix(torrentName, filter.value)
+		case filterByEndsWith:
+			matched = strings.HasSuffix(torrentName, filter.value)
+		case filterByExactMatch:
+			matched = torrentName == filter.value
+		case filterByExclude:
+			matched = !strings.Contains(torrentName, filter.value)
+		case filterByNotStartsWith:
+			matched = !strings.HasPrefix(torrentName, filter.value)
+		case filterByNotEndsWith:
+			matched = !strings.HasSuffix(torrentName, filter.value)
+		case filterByRegex:
+			matched = filter.regex.MatchString(torrentName)
+		case filterByNotRegex:
+			matched = !filter.regex.MatchString(torrentName)
+		case filterByNotExactMatch:
+			matched = torrentName != filter.value
+		case filterBySizeGT:
+			matched = file.size > filter.sizeThreshold
+		case filterBySizeLT:
+			matched = file.size < filter.sizeThreshold
+		case filterBLastAdded:
+			matched = file.modTime.After(now.Add(-filter.ageThreshold))
+		}
+		if !matched {
+			return false // All filters must match
+		}
+	}
+
+	// If we get here, all filters matched
+	return true
+}
+
+func (tc *torrentCache) getAll() map[string]CachedTorrent {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	result := make(map[string]CachedTorrent)
+	for name, torrent := range tc.byID {
+		result[name] = torrent
+	}
+	return result
+}
+
+func (tc *torrentCache) getIdMaps() map[string]struct{} {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	res := make(map[string]struct{}, len(tc.byID))
+	for id := range tc.byID {
+		res[id] = struct{}{}
+	}
+	return res
+}
+
+func (tc *torrentCache) removeId(id string) {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	delete(tc.byID, id)
+	tc.sortNeeded.Store(true)
+}
+
+func (tc *torrentCache) remove(name string) {
+	tc.mu.Lock()
+	defer tc.mu.Unlock()
+	delete(tc.byName, name)
+	tc.sortNeeded.Store(true)
+}

pkg/debrid/debrid/worker.go

@@ -1,75 +1,60 @@
 package debrid
 
-import "time"
+import (
+	"context"
+	"github.com/go-co-op/gocron/v2"
+	"github.com/sirrobot01/decypharr/internal/utils"
+)
 
-func (c *Cache) Refresh() error {
+func (c *Cache) StartSchedule(ctx context.Context) error {
 	// For now, we just want to refresh the listing and download links
-	//go c.refreshDownloadLinksWorker()
-	go c.refreshTorrentsWorker()
-	go c.resetInvalidLinksWorker()
+
+	// Schedule download link refresh job
+	if jd, err := utils.ConvertToJobDef(c.downloadLinksRefreshInterval); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to convert download link refresh interval to job definition")
+	} else {
+		// Schedule the job
+		if _, err := c.scheduler.NewJob(jd, gocron.NewTask(func() {
+			c.refreshDownloadLinks(ctx)
+		}), gocron.WithContext(ctx)); err != nil {
+			c.logger.Error().Err(err).Msg("Failed to create download link refresh job")
+		} else {
+			c.logger.Debug().Msgf("Download link refresh job scheduled for every %s", c.downloadLinksRefreshInterval)
+		}
+	}
+
+	// Schedule torrent refresh job
+	if jd, err := utils.ConvertToJobDef(c.torrentRefreshInterval); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to convert torrent refresh interval to job definition")
+	} else {
+		// Schedule the job
+		if _, err := c.scheduler.NewJob(jd, gocron.NewTask(func() {
+			c.refreshTorrents(ctx)
+		}), gocron.WithContext(ctx)); err != nil {
+			c.logger.Error().Err(err).Msg("Failed to create torrent refresh job")
+		} else {
+			c.logger.Debug().Msgf("Torrent refresh job scheduled for every %s", c.torrentRefreshInterval)
+		}
+	}
+
+	// Schedule the reset invalid links job
+	// This job will run every at 00:00 CET
+	// and reset the invalid links in the cache
+	if jd, err := utils.ConvertToJobDef("00:00"); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to convert link reset interval to job definition")
+	} else {
+		// Schedule the job
+		if _, err := c.cetScheduler.NewJob(jd, gocron.NewTask(func() {
+			c.resetInvalidLinks()
+		}), gocron.WithContext(ctx)); err != nil {
+			c.logger.Error().Err(err).Msg("Failed to create link reset job")
+		} else {
+			c.logger.Debug().Msgf("Link reset job scheduled for every midnight, CET")
+		}
+	}
+
+	// Start the scheduler
+	c.scheduler.Start()
+	c.cetScheduler.Start()
 	return nil
 }
-
-func (c *Cache) refreshDownloadLinksWorker() {
-	refreshTicker := time.NewTicker(c.downloadLinksRefreshInterval)
-	defer refreshTicker.Stop()
-
-	for range refreshTicker.C {
-		c.refreshDownloadLinks()
-	}
-}
-
-func (c *Cache) refreshTorrentsWorker() {
-	refreshTicker := time.NewTicker(c.torrentRefreshInterval)
-	defer refreshTicker.Stop()
-
-	for range refreshTicker.C {
-		c.refreshTorrents()
-	}
-}
-
-func (c *Cache) resetInvalidLinksWorker() {
-	// Calculate time until next 00:00 CET
-	now := time.Now()
-	loc, err := time.LoadLocation("CET")
-	if err != nil {
-		// Fallback if CET timezone can't be loaded
-		c.logger.Error().Err(err).Msg("Failed to load CET timezone, using local time")
-		loc = time.Local
-	}
-
-	nowInCET := now.In(loc)
-	next := time.Date(
-		nowInCET.Year(),
-		nowInCET.Month(),
-		nowInCET.Day(),
-		0, 0, 0, 0,
-		loc,
-	)
-
-	// If it's already past 12:00 CET today, schedule for tomorrow
-	if nowInCET.After(next) {
-		next = next.Add(24 * time.Hour)
-	}
-
-	// Duration until next 12:00 CET
-	initialWait := next.Sub(nowInCET)
-
-	// Set up initial timer
-	timer := time.NewTimer(initialWait)
-	defer timer.Stop()
-
-	c.logger.Debug().Msgf("Scheduled Links Reset at %s (in %s)", next.Format("2006-01-02 15:04:05 MST"), initialWait)
-
-	// Wait for the first execution
-	<-timer.C
-	c.resetInvalidLinks()
-
-	// Now set up the daily ticker
-	refreshTicker := time.NewTicker(24 * time.Hour)
-	defer refreshTicker.Stop()
-
-	for range refreshTicker.C {
-		c.resetInvalidLinks()
-	}
-}

pkg/debrid/debrid/xml.go

@@ -1,125 +1 @@
 package debrid
-
-import (
-	"fmt"
-	"github.com/beevik/etree"
-	"github.com/sirrobot01/decypharr/internal/request"
-	"net/http"
-	"os"
-	path "path/filepath"
-	"time"
-)
-
-func (c *Cache) refreshXml() error {
-	parents := []string{"__all__", "torrents"}
-	torrents := c.GetListing()
-	for _, parent := range parents {
-		if err := c.refreshParentXml(torrents, parent); err != nil {
-			return fmt.Errorf("failed to refresh XML for %s: %v", parent, err)
-		}
-	}
-	c.logger.Trace().Msgf("Refreshed XML cache for %s", c.client.GetName())
-	return nil
-}
-
-func (c *Cache) refreshParentXml(torrents []os.FileInfo, parent string) error {
-	// Define the WebDAV namespace
-	davNS := "DAV:"
-
-	// Create the root multistatus element
-	doc := etree.NewDocument()
-	doc.CreateProcInst("xml", `version="1.0" encoding="UTF-8"`)
-
-	multistatus := doc.CreateElement("D:multistatus")
-	multistatus.CreateAttr("xmlns:D", davNS)
-
-	// Get the current timestamp in RFC1123 format (WebDAV format)
-	currentTime := time.Now().UTC().Format(http.TimeFormat)
-
-	// Add the parent directory
-	baseUrl := path.Clean(fmt.Sprintf("/webdav/%s/%s", c.client.GetName(), parent))
-	parentPath := fmt.Sprintf("%s/", baseUrl)
-	addDirectoryResponse(multistatus, parentPath, parent, currentTime)
-
-	// Add torrents to the XML
-	for _, torrent := range torrents {
-		name := torrent.Name()
-		// Note the path structure change - parent first, then torrent name
-		torrentPath := fmt.Sprintf("/webdav/%s/%s/%s/",
-			c.client.GetName(),
-			parent,
-			name,
-		)
-
-		addDirectoryResponse(multistatus, torrentPath, name, currentTime)
-	}
-
-	// Convert to XML string
-	xmlData, err := doc.WriteToBytes()
-	if err != nil {
-		return fmt.Errorf("failed to generate XML: %v", err)
-	}
-
-	// Store in cache
-	key0 := fmt.Sprintf("propfind:%s:0", baseUrl)
-	key1 := fmt.Sprintf("propfind:%s:1", baseUrl)
-
-	res := PropfindResponse{
-		Data:        xmlData,
-		GzippedData: request.Gzip(xmlData),
-		Ts:          time.Now(),
-	}
-	c.PropfindResp.Store(key0, res)
-	c.PropfindResp.Store(key1, res)
-	return nil
-}
-
-func addDirectoryResponse(multistatus *etree.Element, href, displayName, modTime string) *etree.Element {
-	responseElem := multistatus.CreateElement("D:response")
-
-	// Add href - ensure it's properly formatted
-	hrefElem := responseElem.CreateElement("D:href")
-	hrefElem.SetText(href)
-
-	// Add propstat
-	propstatElem := responseElem.CreateElement("D:propstat")
-
-	// Add prop
-	propElem := propstatElem.CreateElement("D:prop")
-
-	// Add resource type (collection = directory)
-	resourceTypeElem := propElem.CreateElement("D:resourcetype")
-	resourceTypeElem.CreateElement("D:collection")
-
-	// Add display name
-	displayNameElem := propElem.CreateElement("D:displayname")
-	displayNameElem.SetText(displayName)
-
-	// Add last modified time
-	lastModElem := propElem.CreateElement("D:getlastmodified")
-	lastModElem.SetText(modTime)
-
-	// Add content type for directories
-	contentTypeElem := propElem.CreateElement("D:getcontenttype")
-	contentTypeElem.SetText("httpd/unix-directory")
-
-	// Add length (size) - directories typically have zero size
-	contentLengthElem := propElem.CreateElement("D:getcontentlength")
-	contentLengthElem.SetText("0")
-
-	// Add supported lock
-	lockElem := propElem.CreateElement("D:supportedlock")
-	lockEntryElem := lockElem.CreateElement("D:lockentry")
-
-	lockScopeElem := lockEntryElem.CreateElement("D:lockscope")
-	lockScopeElem.CreateElement("D:exclusive")
-
-	lockTypeElem := lockEntryElem.CreateElement("D:locktype")
-	lockTypeElem.CreateElement("D:write")
-
-	// Add status
-	statusElem := propstatElem.CreateElement("D:status")
-	statusElem.SetText("HTTP/1.1 200 OK")
-
-	return responseElem
-}

pkg/debrid/debrid_link/debrid_link.go

@@ -2,16 +2,14 @@ package debrid_link
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
-	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"slices"
 	"strconv"
 	"time"
 
@@ -23,13 +21,14 @@ type DebridLink struct {
 	Name             string
 	Host             string `json:"host"`
 	APIKey           string
-	DownloadKeys     *xsync.MapOf[string, types.Account]
+	accounts         map[string]types.Account
 	DownloadUncached bool
 	client           *request.Client
 
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
 func (dl *DebridLink) GetName() string {
@@ -92,6 +91,65 @@ func (dl *DebridLink) IsAvailable(hashes []string) map[string]bool {
 	return result
 }
 
+func (dl *DebridLink) GetTorrent(torrentId string) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/seedbox/%s", dl.Host, torrentId)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := dl.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var res torrentInfo
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		return nil, err
+	}
+	if !res.Success || res.Value == nil {
+		return nil, fmt.Errorf("error getting torrent")
+	}
+	data := *res.Value
+
+	if len(data) == 0 {
+		return nil, fmt.Errorf("torrent not found")
+	}
+	t := data[0]
+	name := utils.RemoveInvalidChars(t.Name)
+	torrent := &types.Torrent{
+		Id:               t.ID,
+		Name:             name,
+		Bytes:            t.TotalSize,
+		Status:           "downloaded",
+		Filename:         name,
+		OriginalFilename: name,
+		MountPath:        dl.MountPath,
+		Debrid:           dl.Name,
+		Added:            time.Unix(t.Created, 0).Format(time.RFC3339),
+	}
+	cfg := config.Get()
+	for _, f := range t.Files {
+		if !cfg.IsSizeAllowed(f.Size) {
+			continue
+		}
+		file := types.File{
+			TorrentId: t.ID,
+			Id:        f.ID,
+			Name:      f.Name,
+			Size:      f.Size,
+			Path:      f.Name,
+			DownloadLink: &types.DownloadLink{
+				Filename:     f.Name,
+				Link:         f.DownloadURL,
+				DownloadLink: f.DownloadURL,
+				Generated:    time.Now(),
+				AccountId:    "0",
+			},
+			Link: f.DownloadURL,
+		}
+		torrent.Files[file.Name] = file
+	}
+
+	return torrent, nil
+}
+
 func (dl *DebridLink) UpdateTorrent(t *types.Torrent) error {
 	url := fmt.Sprintf("%s/seedbox/list?ids=%s", dl.Host, t.Id)
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
@@ -99,7 +157,7 @@ func (dl *DebridLink) UpdateTorrent(t *types.Torrent) error {
 	if err != nil {
 		return err
 	}
-	var res TorrentInfo
+	var res torrentInfo
 	err = json.Unmarshal(resp, &res)
 	if err != nil {
 		return err
@@ -131,18 +189,26 @@ func (dl *DebridLink) UpdateTorrent(t *types.Torrent) error {
 	t.Seeders = data.PeersConnected
 	t.Filename = name
 	t.OriginalFilename = name
+	t.Added = time.Unix(data.Created, 0).Format(time.RFC3339)
 	cfg := config.Get()
 	for _, f := range data.Files {
 		if !cfg.IsSizeAllowed(f.Size) {
 			continue
 		}
 		file := types.File{
-			Id:           f.ID,
-			Name:         f.Name,
-			Size:         f.Size,
-			Path:         f.Name,
-			DownloadLink: f.DownloadURL,
-			Link:         f.DownloadURL,
+			TorrentId: t.Id,
+			Id:        f.ID,
+			Name:      f.Name,
+			Size:      f.Size,
+			Path:      f.Name,
+			DownloadLink: &types.DownloadLink{
+				Filename:     f.Name,
+				Link:         f.DownloadURL,
+				DownloadLink: f.DownloadURL,
+				Generated:    time.Now(),
+				AccountId:    "0",
+			},
+			Link: f.DownloadURL,
 		}
 		t.Files[f.Name] = file
 	}
@@ -181,15 +247,23 @@ func (dl *DebridLink) SubmitMagnet(t *types.Torrent) (*types.Torrent, error) {
 	t.OriginalFilename = name
 	t.MountPath = dl.MountPath
 	t.Debrid = dl.Name
+	t.Added = time.Unix(data.Created, 0).Format(time.RFC3339)
 	for _, f := range data.Files {
 		file := types.File{
-			Id:           f.ID,
-			Name:         f.Name,
-			Size:         f.Size,
-			Path:         f.Name,
-			Link:         f.DownloadURL,
-			DownloadLink: f.DownloadURL,
-			Generated:    time.Now(),
+			TorrentId: t.Id,
+			Id:        f.ID,
+			Name:      f.Name,
+			Size:      f.Size,
+			Path:      f.Name,
+			Link:      f.DownloadURL,
+			DownloadLink: &types.DownloadLink{
+				Filename:     f.Name,
+				Link:         f.DownloadURL,
+				DownloadLink: f.DownloadURL,
+				Generated:    time.Now(),
+				AccountId:    "0",
+			},
+			Generated: time.Now(),
 		}
 		t.Files[f.Name] = file
 	}
@@ -211,7 +285,7 @@ func (dl *DebridLink) CheckStatus(torrent *types.Torrent, isSymlink bool) (*type
 				return torrent, err
 			}
 			break
-		} else if slices.Contains(dl.GetDownloadingStatus(), status) {
+		} else if utils.Contains(dl.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -241,12 +315,12 @@ func (dl *DebridLink) GenerateDownloadLinks(t *types.Torrent) error {
 	return nil
 }
 
-func (dl *DebridLink) GetDownloads() (map[string]types.DownloadLinks, error) {
+func (dl *DebridLink) GetDownloads() (map[string]types.DownloadLink, error) {
 	return nil, nil
 }
 
-func (dl *DebridLink) GetDownloadLink(t *types.Torrent, file *types.File) (string, string, error) {
-	return file.DownloadLink, "0", nil
+func (dl *DebridLink) GetDownloadLink(t *types.Torrent, file *types.File) (*types.DownloadLink, error) {
+	return file.DownloadLink, nil
 }
 
 func (dl *DebridLink) GetDownloadingStatus() []string {
@@ -254,7 +328,7 @@ func (dl *DebridLink) GetDownloadingStatus() []string {
 }
 
 func (dl *DebridLink) GetCheckCached() bool {
-	return dl.CheckCached
+	return dl.checkCached
 }
 
 func (dl *DebridLink) GetDownloadUncached() bool {
@@ -276,25 +350,26 @@ func New(dc config.Debrid) *DebridLink {
 		request.WithProxy(dc.Proxy),
 	)
 
-	accounts := xsync.NewMapOf[string, types.Account]()
+	accounts := make(map[string]types.Account)
 	for idx, key := range dc.DownloadAPIKeys {
 		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
+		accounts[id] = types.Account{
 			Name:  key,
 			ID:    id,
 			Token: key,
-		})
+		}
 	}
 	return &DebridLink{
 		Name:             "debridlink",
-		Host:             dc.Host,
+		Host:             "https://debrid-link.com/api/v2",
 		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
+		accounts:         accounts,
 		DownloadUncached: dc.DownloadUncached,
 		client:           client,
 		MountPath:        dc.Folder,
 		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
+		checkCached:      dc.CheckCached,
+		addSamples:       dc.AddSamples,
 	}
 }
 
@@ -324,7 +399,7 @@ func (dl *DebridLink) getTorrents(page, perPage int) ([]*types.Torrent, error) {
 	if err != nil {
 		return torrents, err
 	}
-	var res TorrentInfo
+	var res torrentInfo
 	err = json.Unmarshal(resp, &res)
 	if err != nil {
 		dl.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
@@ -351,6 +426,7 @@ func (dl *DebridLink) getTorrents(page, perPage int) ([]*types.Torrent, error) {
 			Files:            make(map[string]types.File),
 			Debrid:           dl.Name,
 			MountPath:        dl.MountPath,
+			Added:            time.Unix(t.Created, 0).Format(time.RFC3339),
 		}
 		cfg := config.Get()
 		for _, f := range t.Files {
@@ -358,12 +434,19 @@ func (dl *DebridLink) getTorrents(page, perPage int) ([]*types.Torrent, error) {
 				continue
 			}
 			file := types.File{
-				Id:           f.ID,
-				Name:         f.Name,
-				Size:         f.Size,
-				Path:         f.Name,
-				DownloadLink: f.DownloadURL,
-				Link:         f.DownloadURL,
+				TorrentId: torrent.Id,
+				Id:        f.ID,
+				Name:      f.Name,
+				Size:      f.Size,
+				Path:      f.Name,
+				DownloadLink: &types.DownloadLink{
+					Filename:     f.Name,
+					Link:         f.DownloadURL,
+					DownloadLink: f.DownloadURL,
+					Generated:    time.Now(),
+					AccountId:    "0",
+				},
+				Link: f.DownloadURL,
 			}
 			torrent.Files[f.Name] = file
 		}
@@ -385,3 +468,7 @@ func (dl *DebridLink) DisableAccount(accountId string) {
 
 func (dl *DebridLink) ResetActiveDownloadKeys() {
 }
+
+func (dl *DebridLink) DeleteDownloadLink(linkId string) error {
+	return nil
+}

pkg/debrid/debrid_link/types.go

@@ -14,7 +14,7 @@ type AvailableResponse APIResponse[map[string]map[string]struct {
 	} `json:"files"`
 }]
 
-type debridLinkTorrentInfo struct {
+type _torrentInfo struct {
 	ID             string  `json:"id"`
 	Name           string  `json:"name"`
 	HashString     string  `json:"hashString"`
@@ -40,6 +40,6 @@ type debridLinkTorrentInfo struct {
 	UploadSpeed     int64   `json:"uploadSpeed"`
 }
 
-type TorrentInfo APIResponse[[]debridLinkTorrentInfo]
+type torrentInfo APIResponse[[]_torrentInfo]
 
-type SubmitTorrentInfo APIResponse[debridLinkTorrentInfo]
+type SubmitTorrentInfo APIResponse[_torrentInfo]

pkg/debrid/realdebrid/realdebrid.go

@@ -2,10 +2,9 @@ package realdebrid
 
 import (
 	"bytes"
+	"encoding/json"
 	"errors"
 	"fmt"
-	"github.com/goccy/go-json"
-	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
@@ -16,7 +15,6 @@ import (
 	"net/http"
 	gourl "net/url"
 	"path/filepath"
-	"slices"
 	"sort"
 	"strconv"
 	"strings"
@@ -28,8 +26,10 @@ type RealDebrid struct {
 	Name string
 	Host string `json:"host"`
 
-	APIKey       string
-	DownloadKeys *xsync.MapOf[string, types.Account] // index | Account
+	APIKey             string
+	currentDownloadKey string
+	accounts           map[string]types.Account
+	accountsMutex      sync.RWMutex
 
 	DownloadUncached bool
 	client           *request.Client
@@ -37,7 +37,8 @@ type RealDebrid struct {
 
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
 func New(dc config.Debrid) *RealDebrid {
@@ -48,51 +49,47 @@ func New(dc config.Debrid) *RealDebrid {
 	}
 	_log := logger.New(dc.Name)
 
-	accounts := xsync.NewMapOf[string, types.Account]()
-	firstDownloadKey := dc.DownloadAPIKeys[0]
+	accounts := make(map[string]types.Account)
+	currentDownloadKey := dc.DownloadAPIKeys[0]
 	for idx, key := range dc.DownloadAPIKeys {
 		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
+		accounts[id] = types.Account{
 			Name:  key,
 			ID:    id,
 			Token: key,
-		})
+		}
 	}
 
 	downloadHeaders := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", firstDownloadKey),
+		"Authorization": fmt.Sprintf("Bearer %s", currentDownloadKey),
 	}
 
-	downloadClient := request.New(
-		request.WithHeaders(downloadHeaders),
-		request.WithRateLimiter(rl),
-		request.WithLogger(_log),
-		request.WithMaxRetries(5),
-		request.WithRetryableStatus(429, 447),
-		request.WithProxy(dc.Proxy),
-		request.WithStatusCooldown(447, 10*time.Second), // 447 is a fair use error
-	)
-
-	client := request.New(
-		request.WithHeaders(headers),
-		request.WithRateLimiter(rl),
-		request.WithLogger(_log),
-		request.WithMaxRetries(5),
-		request.WithRetryableStatus(429),
-		request.WithProxy(dc.Proxy),
-	)
-
 	return &RealDebrid{
 		Name:             "realdebrid",
-		Host:             dc.Host,
+		Host:             "https://api.real-debrid.com/rest/1.0",
 		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
+		accounts:         accounts,
 		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-		downloadClient:   downloadClient,
-		MountPath:        dc.Folder,
-		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
+		client: request.New(
+			request.WithHeaders(headers),
+			request.WithRateLimiter(rl),
+			request.WithLogger(_log),
+			request.WithMaxRetries(5),
+			request.WithRetryableStatus(429, 502),
+			request.WithProxy(dc.Proxy),
+		),
+		downloadClient: request.New(
+			request.WithHeaders(downloadHeaders),
+			request.WithLogger(_log),
+			request.WithMaxRetries(10),
+			request.WithRetryableStatus(429, 447, 502),
+			request.WithProxy(dc.Proxy),
+		),
+		currentDownloadKey: currentDownloadKey,
+		MountPath:          dc.Folder,
+		logger:             logger.New(dc.Name),
+		checkCached:        dc.CheckCached,
+		addSamples:         dc.AddSamples,
 	}
 }
 
@@ -104,16 +101,17 @@ func (r *RealDebrid) GetLogger() zerolog.Logger {
 	return r.logger
 }
 
-func getSelectedFiles(t *types.Torrent, data TorrentInfo) map[string]types.File {
+func getSelectedFiles(t *types.Torrent, data torrentInfo) map[string]types.File {
 	selectedFiles := make([]types.File, 0)
 	for _, f := range data.Files {
 		if f.Selected == 1 {
 			name := filepath.Base(f.Path)
 			file := types.File{
-				Name: name,
-				Path: name,
-				Size: f.Bytes,
-				Id:   strconv.Itoa(f.ID),
+				TorrentId: t.Id,
+				Name:      name,
+				Path:      name,
+				Size:      f.Bytes,
+				Id:        strconv.Itoa(f.ID),
 			}
 			selectedFiles = append(selectedFiles, file)
 		}
@@ -132,14 +130,14 @@ func getSelectedFiles(t *types.Torrent, data TorrentInfo) map[string]types.File
 // getTorrentFiles returns a list of torrent files from the torrent info
 // validate is used to determine if the files should be validated
 // if validate is false, selected files will be returned
-func getTorrentFiles(t *types.Torrent, data TorrentInfo) map[string]types.File {
+func (r *RealDebrid) getTorrentFiles(t *types.Torrent, data torrentInfo) map[string]types.File {
 	files := make(map[string]types.File)
 	cfg := config.Get()
 	idx := 0
 
 	for _, f := range data.Files {
 		name := filepath.Base(f.Path)
-		if utils.IsSampleFile(f.Path) {
+		if !r.addSamples && utils.IsSampleFile(f.Path) {
 			// Skip sample files
 			continue
 		}
@@ -152,10 +150,11 @@ func getTorrentFiles(t *types.Torrent, data TorrentInfo) map[string]types.File {
 		}
 
 		file := types.File{
-			Name: name,
-			Path: name,
-			Size: f.Bytes,
-			Id:   strconv.Itoa(f.ID),
+			TorrentId: t.Id,
+			Name:      name,
+			Path:      name,
+			Size:      f.Bytes,
+			Id:        strconv.Itoa(f.ID),
 		}
 		files[name] = file
 		idx++
@@ -260,15 +259,69 @@ func (r *RealDebrid) addMagnet(t *types.Torrent) (*types.Torrent, error) {
 	return t, nil
 }
 
+func (r *RealDebrid) GetTorrent(torrentId string) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, torrentId)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := r.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("reading response body: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusNotFound {
+			return nil, request.TorrentNotFoundError
+		}
+		return nil, fmt.Errorf("realdebrid API error: Status: %d || Body: %s", resp.StatusCode, string(bodyBytes))
+	}
+	var data torrentInfo
+	err = json.Unmarshal(bodyBytes, &data)
+	if err != nil {
+		return nil, err
+	}
+	t := &types.Torrent{
+		Id:               data.ID,
+		Name:             data.Filename,
+		Bytes:            data.Bytes,
+		Folder:           data.OriginalFilename,
+		Progress:         data.Progress,
+		Speed:            data.Speed,
+		Seeders:          data.Seeders,
+		Added:            data.Added,
+		Status:           data.Status,
+		Filename:         data.Filename,
+		OriginalFilename: data.OriginalFilename,
+		Links:            data.Links,
+		Debrid:           r.Name,
+		MountPath:        r.MountPath,
+	}
+	t.Files = r.getTorrentFiles(t, data) // Get selected files
+	return t, nil
+}
+
 func (r *RealDebrid) UpdateTorrent(t *types.Torrent) error {
 	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, t.Id)
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
+	resp, err := r.client.Do(req)
 	if err != nil {
 		return err
 	}
-	var data TorrentInfo
-	err = json.Unmarshal(resp, &data)
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("reading response body: %w", err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		if resp.StatusCode == http.StatusNotFound {
+			return request.TorrentNotFoundError
+		}
+		return fmt.Errorf("realdebrid API error: Status: %d || Body: %s", resp.StatusCode, string(bodyBytes))
+	}
+	var data torrentInfo
+	err = json.Unmarshal(bodyBytes, &data)
 	if err != nil {
 		return err
 	}
@@ -298,7 +351,7 @@ func (r *RealDebrid) CheckStatus(t *types.Torrent, isSymlink bool) (*types.Torre
 			r.logger.Info().Msgf("ERROR Checking file: %v", err)
 			return t, err
 		}
-		var data TorrentInfo
+		var data torrentInfo
 		if err = json.Unmarshal(resp, &data); err != nil {
 			return t, err
 		}
@@ -316,7 +369,7 @@ func (r *RealDebrid) CheckStatus(t *types.Torrent, isSymlink bool) (*types.Torre
 		t.Debrid = r.Name
 		t.MountPath = r.MountPath
 		if status == "waiting_files_selection" {
-			t.Files = getTorrentFiles(t, data)
+			t.Files = r.getTorrentFiles(t, data)
 			if len(t.Files) == 0 {
 				return t, fmt.Errorf("no video files found")
 			}
@@ -329,10 +382,13 @@ func (r *RealDebrid) CheckStatus(t *types.Torrent, isSymlink bool) (*types.Torre
 			}
 			payload := strings.NewReader(p.Encode())
 			req, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/torrents/selectFiles/%s", r.Host, t.Id), payload)
-			_, err = r.client.MakeRequest(req)
+			res, err := r.client.Do(req)
 			if err != nil {
 				return t, err
 			}
+			if res.StatusCode != http.StatusNoContent {
+				return t, fmt.Errorf("realdebrid API error: Status: %d", res.StatusCode)
+			}
 		} else if status == "downloaded" {
 			t.Files = getSelectedFiles(t, data) // Get selected files
 			r.logger.Info().Msgf("Torrent: %s downloaded to RD", t.Name)
@@ -343,7 +399,7 @@ func (r *RealDebrid) CheckStatus(t *types.Torrent, isSymlink bool) (*types.Torre
 				}
 			}
 			break
-		} else if slices.Contains(r.GetDownloadingStatus(), status) {
+		} else if utils.Contains(r.GetDownloadingStatus(), status) {
 			if !t.DownloadUncached {
 				return t, fmt.Errorf("torrent: %s not cached", t.Name)
 			}
@@ -376,14 +432,13 @@ func (r *RealDebrid) GenerateDownloadLinks(t *types.Torrent) error {
 		go func(file types.File) {
 			defer wg.Done()
 
-			link, accountId, err := r.GetDownloadLink(t, &file)
+			link, err := r.GetDownloadLink(t, &file)
 			if err != nil {
 				errCh <- err
 				return
 			}
 
 			file.DownloadLink = link
-			file.AccountId = accountId
 			filesCh <- file
 		}(f)
 	}
@@ -427,99 +482,108 @@ func (r *RealDebrid) CheckLink(link string) error {
 	return nil
 }
 
-func (r *RealDebrid) _getDownloadLink(file *types.File) (string, error) {
+func (r *RealDebrid) _getDownloadLink(file *types.File) (*types.DownloadLink, error) {
 	url := fmt.Sprintf("%s/unrestrict/link/", r.Host)
 	payload := gourl.Values{
 		"link": {file.Link},
 	}
 	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
 	resp, err := r.downloadClient.Do(req)
+
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 	defer resp.Body.Close()
 	if resp.StatusCode != http.StatusOK {
 		// Read the response body to get the error message
 		b, err := io.ReadAll(resp.Body)
 		if err != nil {
-			return "", err
+			return nil, err
 		}
 		var data ErrorResponse
 		if err = json.Unmarshal(b, &data); err != nil {
-			return "", err
+			return nil, fmt.Errorf("error unmarshalling %d || %s \n %s", resp.StatusCode, err, string(b))
 		}
 		switch data.ErrorCode {
-		case 23:
-			return "", request.TrafficExceededError
-		case 24:
-			return "", request.HosterUnavailableError // Link has been nerfed
 		case 19:
-			return "", request.HosterUnavailableError // File has been removed
-		case 36:
-			return "", request.TrafficExceededError // traffic exceeded
+			return nil, request.HosterUnavailableError // File has been removed
+		case 23:
+			return nil, request.TrafficExceededError
+		case 24:
+			return nil, request.HosterUnavailableError // Link has been nerfed
 		case 34:
-			return "", request.TrafficExceededError // traffic exceeded
+			return nil, request.TrafficExceededError // traffic exceeded
+		case 35:
+			return nil, request.HosterUnavailableError
+		case 36:
+			return nil, request.TrafficExceededError // traffic exceeded
 		default:
-			return "", fmt.Errorf("realdebrid API error: Status: %d || Code: %d", resp.StatusCode, data.ErrorCode)
+			return nil, fmt.Errorf("realdebrid API error: Status: %d || Code: %d", resp.StatusCode, data.ErrorCode)
 		}
 	}
 	b, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return "", err
+		return nil, err
 	}
 	var data UnrestrictResponse
 	if err = json.Unmarshal(b, &data); err != nil {
-		return "", err
+		return nil, fmt.Errorf("realdebrid API error: Error unmarshalling response: %w", err)
 	}
-	return data.Download, nil
+	if data.Download == "" {
+		return nil, fmt.Errorf("realdebrid API error: download link not found")
+	}
+	return &types.DownloadLink{
+		Filename:     data.Filename,
+		Size:         data.Filesize,
+		Link:         data.Link,
+		DownloadLink: data.Download,
+		Generated:    time.Now(),
+	}, nil
 
 }
 
-func (r *RealDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (string, string, error) {
-	defer r.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", r.APIKey))
-	var (
-		downloadLink string
-		accountId    string
-		err          error
-	)
-	accounts := r.getActiveAccounts()
-	if len(accounts) < 1 {
-		// No active download keys. It's likely that the key has reached bandwidth limit
-		return "", "", fmt.Errorf("no active download keys")
-	}
-	for _, account := range accounts {
-		r.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", account.Token))
-		downloadLink, err = r._getDownloadLink(file)
-		if err != nil {
-			if errors.Is(err, request.TrafficExceededError) {
-				continue
-			}
-			// If the error is not traffic exceeded, skip generating the link with a new key
-			return "", "", err
-		} else {
-			// If we successfully generated a link, break the loop
-			accountId = account.ID
-			file.AccountId = accountId
-			break
-		}
+func (r *RealDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (*types.DownloadLink, error) {
 
+	if r.currentDownloadKey == "" {
+		// If no download key is set, use the first one
+		accounts := r.getActiveAccounts()
+		if len(accounts) < 1 {
+			// No active download keys. It's likely that the key has reached bandwidth limit
+			return nil, fmt.Errorf("no active download keys")
+		}
+		r.currentDownloadKey = accounts[0].Token
 	}
-	if downloadLink != "" {
-		// If we successfully generated a link, return it
-		return downloadLink, accountId, nil
-	}
-	// If we reach here, it means all keys are disabled or traffic exceeded
+
+	r.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", r.currentDownloadKey))
+	downloadLink, err := r._getDownloadLink(file)
+	retries := 0
 	if err != nil {
 		if errors.Is(err, request.TrafficExceededError) {
-			return "", "", request.TrafficExceededError
+			// Retries generating
+			retries = 5
+		} else {
+			// If the error is not traffic exceeded, return the error
+			return nil, err
 		}
-		return "", "", fmt.Errorf("error generating download link: %v", err)
 	}
-	return "", "", fmt.Errorf("error generating download link: %v", err)
+	backOff := 1 * time.Second
+	for retries > 0 {
+		downloadLink, err = r._getDownloadLink(file)
+		if err == nil {
+			return downloadLink, nil
+		}
+		if !errors.Is(err, request.TrafficExceededError) {
+			return nil, err
+		}
+		// Add a delay before retrying
+		time.Sleep(backOff)
+		backOff *= 2 // Exponential backoff
+	}
+	return downloadLink, nil
 }
 
 func (r *RealDebrid) GetCheckCached() bool {
-	return r.CheckCached
+	return r.checkCached
 }
 
 func (r *RealDebrid) getTorrents(offset int, limit int) (int, []*types.Torrent, error) {
@@ -552,16 +616,13 @@ func (r *RealDebrid) getTorrents(offset int, limit int) (int, []*types.Torrent,
 	totalItems, _ := strconv.Atoi(resp.Header.Get("X-Total-Count"))
 	var data []TorrentsResponse
 	if err = json.Unmarshal(body, &data); err != nil {
-		return 0, nil, err
+		return 0, torrents, err
 	}
 	filenames := map[string]struct{}{}
 	for _, t := range data {
 		if t.Status != "downloaded" {
 			continue
 		}
-		if _, exists := filenames[t.Filename]; exists {
-			continue
-		}
 		torrents = append(torrents, &types.Torrent{
 			Id:               t.Id,
 			Name:             t.Filename,
@@ -586,32 +647,22 @@ func (r *RealDebrid) GetTorrents() ([]*types.Torrent, error) {
 	limit := 5000
 
 	// Get first batch and total count
-	totalItems, firstBatch, err := r.getTorrents(0, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	allTorrents := firstBatch
-
-	// Calculate remaining requests
-	remaining := totalItems - len(firstBatch)
-	if remaining <= 0 {
-		return allTorrents, nil
-	}
-
-	// Prepare for concurrent fetching
+	allTorrents := make([]*types.Torrent, 0)
 	var fetchError error
-
-	// Calculate how many more requests we need
-	batchCount := (remaining + limit - 1) / limit // ceiling division
-
-	for i := 1; i <= batchCount; i++ {
-		_, batch, err := r.getTorrents(i*limit, limit)
+	offset := 0
+	for {
+		// Fetch next batch of torrents
+		_, torrents, err := r.getTorrents(offset, limit)
 		if err != nil {
 			fetchError = err
-			continue
+			break
 		}
-		allTorrents = append(allTorrents, batch...)
+		totalTorrents := len(torrents)
+		if totalTorrents == 0 {
+			break
+		}
+		allTorrents = append(allTorrents, torrents...)
+		offset += totalTorrents
 	}
 
 	if fetchError != nil {
@@ -621,8 +672,8 @@ func (r *RealDebrid) GetTorrents() ([]*types.Torrent, error) {
 	return allTorrents, nil
 }
 
-func (r *RealDebrid) GetDownloads() (map[string]types.DownloadLinks, error) {
-	links := make(map[string]types.DownloadLinks)
+func (r *RealDebrid) GetDownloads() (map[string]types.DownloadLink, error) {
+	links := make(map[string]types.DownloadLink)
 	offset := 0
 	limit := 1000
 
@@ -655,7 +706,7 @@ func (r *RealDebrid) GetDownloads() (map[string]types.DownloadLinks, error) {
 	return links, nil
 }
 
-func (r *RealDebrid) _getDownloads(offset int, limit int) ([]types.DownloadLinks, error) {
+func (r *RealDebrid) _getDownloads(offset int, limit int) ([]types.DownloadLink, error) {
 	url := fmt.Sprintf("%s/downloads?limit=%d", r.Host, limit)
 	if offset > 0 {
 		url = fmt.Sprintf("%s&offset=%d", url, offset)
@@ -669,9 +720,9 @@ func (r *RealDebrid) _getDownloads(offset int, limit int) ([]types.DownloadLinks
 	if err = json.Unmarshal(resp, &data); err != nil {
 		return nil, err
 	}
-	links := make([]types.DownloadLinks, 0)
+	links := make([]types.DownloadLink, 0)
 	for _, d := range data {
-		links = append(links, types.DownloadLinks{
+		links = append(links, types.DownloadLink{
 			Filename:     d.Filename,
 			Size:         d.Filesize,
 			Link:         d.Link,
@@ -697,32 +748,53 @@ func (r *RealDebrid) GetMountPath() string {
 }
 
 func (r *RealDebrid) DisableAccount(accountId string) {
-	if value, ok := r.DownloadKeys.Load(accountId); ok {
+	r.accountsMutex.Lock()
+	defer r.accountsMutex.Unlock()
+	if len(r.accounts) == 1 {
+		r.logger.Info().Msgf("Cannot disable last account: %s", accountId)
+		return
+	}
+	r.currentDownloadKey = ""
+	if value, ok := r.accounts[accountId]; ok {
 		value.Disabled = true
-		r.DownloadKeys.Store(accountId, value)
+		r.accounts[accountId] = value
 		r.logger.Info().Msgf("Disabled account Index: %s", value.ID)
 	}
 }
 
 func (r *RealDebrid) ResetActiveDownloadKeys() {
-	r.DownloadKeys.Range(func(key string, value types.Account) bool {
+	r.accountsMutex.Lock()
+	defer r.accountsMutex.Unlock()
+	for key, value := range r.accounts {
 		value.Disabled = false
-		r.DownloadKeys.Store(key, value)
-		return true
-	})
+		r.accounts[key] = value
+	}
 }
 
 func (r *RealDebrid) getActiveAccounts() []types.Account {
+	r.accountsMutex.RLock()
+	defer r.accountsMutex.RUnlock()
 	accounts := make([]types.Account, 0)
-	r.DownloadKeys.Range(func(key string, value types.Account) bool {
+
+	for _, value := range r.accounts {
 		if value.Disabled {
-			return true
+			continue
 		}
 		accounts = append(accounts, value)
-		return true
-	})
+	}
+
+	// Sort accounts by ID
 	sort.Slice(accounts, func(i, j int) bool {
 		return accounts[i].ID < accounts[j].ID
 	})
 	return accounts
 }
+
+func (r *RealDebrid) DeleteDownloadLink(linkId string) error {
+	url := fmt.Sprintf("%s/downloads/delete/%s", r.Host, linkId)
+	req, _ := http.NewRequest(http.MethodDelete, url, nil)
+	if _, err := r.downloadClient.MakeRequest(req); err != nil {
+		return err
+	}
+	return nil
+}

pkg/debrid/realdebrid/types.go

@@ -1,8 +1,8 @@
 package realdebrid
 
 import (
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
 	"time"
 )
 
@@ -70,7 +70,7 @@ type AddMagnetSchema struct {
 	Uri string `json:"uri"`
 }
 
-type TorrentInfo struct {
+type torrentInfo struct {
 	ID               string  `json:"id"`
 	Filename         string  `json:"filename"`
 	OriginalFilename string  `json:"original_filename"`

pkg/debrid/torbox/torbox.go

@@ -2,37 +2,39 @@ package torbox
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
-	"github.com/puzpuzpuz/xsync/v3"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"github.com/sirrobot01/decypharr/pkg/version"
 	"mime/multipart"
 	"net/http"
 	gourl "net/url"
 	"path"
 	"path/filepath"
-	"slices"
+	"runtime"
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 )
 
 type Torbox struct {
 	Name             string
 	Host             string `json:"host"`
 	APIKey           string
-	DownloadKeys     *xsync.MapOf[string, types.Account]
+	accounts         map[string]types.Account
 	DownloadUncached bool
 	client           *request.Client
 
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
 func New(dc config.Debrid) *Torbox {
@@ -40,6 +42,7 @@ func New(dc config.Debrid) *Torbox {
 
 	headers := map[string]string{
 		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+		"User-Agent":    fmt.Sprintf("Decypharr/%s (%s; %s)", version.GetInfo(), runtime.GOOS, runtime.GOARCH),
 	}
 	_log := logger.New(dc.Name)
 	client := request.New(
@@ -49,26 +52,27 @@ func New(dc config.Debrid) *Torbox {
 		request.WithProxy(dc.Proxy),
 	)
 
-	accounts := xsync.NewMapOf[string, types.Account]()
+	accounts := make(map[string]types.Account)
 	for idx, key := range dc.DownloadAPIKeys {
 		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
+		accounts[id] = types.Account{
 			Name:  key,
 			ID:    id,
 			Token: key,
-		})
+		}
 	}
 
 	return &Torbox{
 		Name:             "torbox",
-		Host:             dc.Host,
+		Host:             "https://api.torbox.app/v1",
 		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
+		accounts:         accounts,
 		DownloadUncached: dc.DownloadUncached,
 		client:           client,
 		MountPath:        dc.Folder,
 		logger:           _log,
-		CheckCached:      dc.CheckCached,
+		checkCached:      dc.CheckCached,
+		addSamples:       dc.AddSamples,
 	}
 }
 
@@ -172,13 +176,81 @@ func getTorboxStatus(status string, finished bool) string {
 		"forcedUP", "allocating", "downloading", "metaDL", "pausedDL",
 		"queuedDL", "checkingDL", "forcedDL", "checkingResumeData", "moving"}
 	switch {
-	case slices.Contains(downloading, status):
+	case utils.Contains(downloading, status):
 		return "downloading"
 	default:
 		return "error"
 	}
 }
 
+func (tb *Torbox) GetTorrent(torrentId string) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/api/torrents/mylist/?id=%s", tb.Host, torrentId)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := tb.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var res InfoResponse
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		return nil, err
+	}
+	data := res.Data
+	if data == nil {
+		return nil, fmt.Errorf("error getting torrent")
+	}
+	t := &types.Torrent{
+		Id:               strconv.Itoa(data.Id),
+		Name:             data.Name,
+		Bytes:            data.Size,
+		Folder:           data.Name,
+		Progress:         data.Progress * 100,
+		Status:           getTorboxStatus(data.DownloadState, data.DownloadFinished),
+		Speed:            data.DownloadSpeed,
+		Seeders:          data.Seeds,
+		Filename:         data.Name,
+		OriginalFilename: data.Name,
+		MountPath:        tb.MountPath,
+		Debrid:           tb.Name,
+		Files:            make(map[string]types.File),
+		Added:            data.CreatedAt.Format(time.RFC3339),
+	}
+	cfg := config.Get()
+	for _, f := range data.Files {
+		fileName := filepath.Base(f.Name)
+		if !tb.addSamples && utils.IsSampleFile(f.AbsolutePath) {
+			// Skip sample files
+			continue
+		}
+		if !cfg.IsAllowedFile(fileName) {
+			continue
+		}
+
+		if !cfg.IsSizeAllowed(f.Size) {
+			continue
+		}
+		file := types.File{
+			TorrentId: t.Id,
+			Id:        strconv.Itoa(f.Id),
+			Name:      fileName,
+			Size:      f.Size,
+			Path:      f.Name,
+		}
+		t.Files[fileName] = file
+	}
+	var cleanPath string
+	if len(t.Files) > 0 {
+		cleanPath = path.Clean(data.Files[0].Name)
+	} else {
+		cleanPath = path.Clean(data.Name)
+	}
+
+	t.OriginalFilename = strings.Split(cleanPath, "/")[0]
+	t.Debrid = tb.Name
+
+	return t, nil
+}
+
 func (tb *Torbox) UpdateTorrent(t *types.Torrent) error {
 	url := fmt.Sprintf("%s/api/torrents/mylist/?id=%s", tb.Host, t.Id)
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
@@ -207,7 +279,7 @@ func (tb *Torbox) UpdateTorrent(t *types.Torrent) error {
 	cfg := config.Get()
 	for _, f := range data.Files {
 		fileName := filepath.Base(f.Name)
-		if utils.IsSampleFile(f.AbsolutePath) {
+		if !tb.addSamples && utils.IsSampleFile(f.AbsolutePath) {
 			// Skip sample files
 			continue
 		}
@@ -219,10 +291,11 @@ func (tb *Torbox) UpdateTorrent(t *types.Torrent) error {
 			continue
 		}
 		file := types.File{
-			Id:   strconv.Itoa(f.Id),
-			Name: fileName,
-			Size: f.Size,
-			Path: fileName,
+			TorrentId: t.Id,
+			Id:        strconv.Itoa(f.Id),
+			Name:      fileName,
+			Size:      f.Size,
+			Path:      fileName,
 		}
 		t.Files[fileName] = file
 	}
@@ -255,7 +328,7 @@ func (tb *Torbox) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.To
 				}
 			}
 			break
-		} else if slices.Contains(tb.GetDownloadingStatus(), status) {
+		} else if utils.Contains(tb.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -291,13 +364,12 @@ func (tb *Torbox) GenerateDownloadLinks(t *types.Torrent) error {
 	for _, file := range t.Files {
 		go func() {
 			defer wg.Done()
-			link, accountId, err := tb.GetDownloadLink(t, &file)
+			link, err := tb.GetDownloadLink(t, &file)
 			if err != nil {
 				errCh <- err
 				return
 			}
 			file.DownloadLink = link
-			file.AccountId = accountId
 			filesCh <- file
 		}()
 	}
@@ -324,7 +396,7 @@ func (tb *Torbox) GenerateDownloadLinks(t *types.Torrent) error {
 	return nil
 }
 
-func (tb *Torbox) GetDownloadLink(t *types.Torrent, file *types.File) (string, string, error) {
+func (tb *Torbox) GetDownloadLink(t *types.Torrent, file *types.File) (*types.DownloadLink, error) {
 	url := fmt.Sprintf("%s/api/torrents/requestdl/", tb.Host)
 	query := gourl.Values{}
 	query.Add("torrent_id", t.Id)
@@ -334,17 +406,26 @@ func (tb *Torbox) GetDownloadLink(t *types.Torrent, file *types.File) (string, s
 	req, _ := http.NewRequest(http.MethodGet, url, nil)
 	resp, err := tb.client.MakeRequest(req)
 	if err != nil {
-		return "", "", err
+		return nil, err
 	}
 	var data DownloadLinksResponse
 	if err = json.Unmarshal(resp, &data); err != nil {
-		return "", "", err
+		return nil, err
 	}
 	if data.Data == nil {
-		return "", "", fmt.Errorf("error getting download links")
+		return nil, fmt.Errorf("error getting download links")
 	}
 	link := *data.Data
-	return link, "0", nil
+	if link == "" {
+		return nil, fmt.Errorf("error getting download links")
+	}
+	return &types.DownloadLink{
+		Link:         file.Link,
+		DownloadLink: link,
+		Id:           file.Id,
+		AccountId:    "0",
+		Generated:    time.Now(),
+	}, nil
 }
 
 func (tb *Torbox) GetDownloadingStatus() []string {
@@ -352,7 +433,7 @@ func (tb *Torbox) GetDownloadingStatus() []string {
 }
 
 func (tb *Torbox) GetCheckCached() bool {
-	return tb.CheckCached
+	return tb.checkCached
 }
 
 func (tb *Torbox) GetTorrents() ([]*types.Torrent, error) {
@@ -363,7 +444,7 @@ func (tb *Torbox) GetDownloadUncached() bool {
 	return tb.DownloadUncached
 }
 
-func (tb *Torbox) GetDownloads() (map[string]types.DownloadLinks, error) {
+func (tb *Torbox) GetDownloads() (map[string]types.DownloadLink, error) {
 	return nil, nil
 }
 
@@ -381,3 +462,7 @@ func (tb *Torbox) DisableAccount(accountId string) {
 func (tb *Torbox) ResetActiveDownloadKeys() {
 
 }
+
+func (tb *Torbox) DeleteDownloadLink(linkId string) error {
+	return nil
+}

pkg/debrid/types/client.go

@@ -8,19 +8,21 @@ type Client interface {
 	SubmitMagnet(tr *Torrent) (*Torrent, error)
 	CheckStatus(tr *Torrent, isSymlink bool) (*Torrent, error)
 	GenerateDownloadLinks(tr *Torrent) error
-	GetDownloadLink(tr *Torrent, file *File) (string, string, error)
+	GetDownloadLink(tr *Torrent, file *File) (*DownloadLink, error)
 	DeleteTorrent(torrentId string) error
 	IsAvailable(infohashes []string) map[string]bool
 	GetCheckCached() bool
 	GetDownloadUncached() bool
 	UpdateTorrent(torrent *Torrent) error
+	GetTorrent(torrentId string) (*Torrent, error)
 	GetTorrents() ([]*Torrent, error)
 	GetName() string
 	GetLogger() zerolog.Logger
 	GetDownloadingStatus() []string
-	GetDownloads() (map[string]DownloadLinks, error)
+	GetDownloads() (map[string]DownloadLink, error)
 	CheckLink(link string) error
 	GetMountPath() string
 	DisableAccount(string)
 	ResetActiveDownloadKeys()
+	DeleteDownloadLink(linkId string) error
 }

pkg/debrid/types/torrent.go

@@ -2,7 +2,6 @@ package types
 
 import (
 	"fmt"
-	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/arr"
@@ -30,6 +29,7 @@ type Torrent struct {
 	Seeders          int             `json:"seeders"`
 	Links            []string        `json:"links"`
 	MountPath        string          `json:"mount_path"`
+	DeletedFiles     []string        `json:"deleted_files"`
 
 	Debrid string `json:"debrid"`
 
@@ -39,13 +39,18 @@ type Torrent struct {
 	DownloadUncached bool       `json:"-"`
 }
 
-type DownloadLinks struct {
+type DownloadLink struct {
 	Filename     string    `json:"filename"`
 	Link         string    `json:"link"`
 	DownloadLink string    `json:"download_link"`
 	Generated    time.Time `json:"generated"`
 	Size         int64     `json:"size"`
 	Id           string    `json:"id"`
+	AccountId    string    `json:"account_id"`
+}
+
+func (d *DownloadLink) String() string {
+	return d.DownloadLink
 }
 
 func (t *Torrent) GetSymlinkFolder(parent string) string {
@@ -53,7 +58,7 @@ func (t *Torrent) GetSymlinkFolder(parent string) string {
 }
 
 func (t *Torrent) GetMountFolder(rClonePath string) (string, error) {
-	_log := logger.GetDefaultLogger()
+	_log := logger.Default()
 	possiblePaths := []string{
 		t.OriginalFilename,
 		t.Filename,
@@ -71,35 +76,35 @@ func (t *Torrent) GetMountFolder(rClonePath string) (string, error) {
 	return "", fmt.Errorf("no path found")
 }
 
-type File struct {
-	Id           string    `json:"id"`
-	Name         string    `json:"name"`
-	Size         int64     `json:"size"`
-	Path         string    `json:"path"`
-	Link         string    `json:"link"`
-	DownloadLink string    `json:"download_link"`
-	AccountId    string    `json:"account_id"`
-	Generated    time.Time `json:"generated"`
+func (t *Torrent) GetFile(filename string) (File, bool) {
+	f, ok := t.Files[filename]
+	if !ok {
+		return File{}, false
+	}
+	return f, !f.Deleted
 }
 
-func (f *File) IsValid() bool {
-	cfg := config.Get()
-	name := filepath.Base(f.Path)
-	if utils.IsSampleFile(f.Path) {
-		return false
+func (t *Torrent) GetFiles() []File {
+	files := make([]File, 0, len(t.Files))
+	for _, f := range t.Files {
+		if !f.Deleted {
+			files = append(files, f)
+		}
 	}
+	return files
+}
 
-	if !cfg.IsAllowedFile(name) {
-		return false
-	}
-	if !cfg.IsSizeAllowed(f.Size) {
-		return false
-	}
-
-	if f.Link == "" {
-		return false
-	}
-	return true
+type File struct {
+	TorrentId    string        `json:"torrent_id"`
+	Id           string        `json:"id"`
+	Name         string        `json:"name"`
+	Size         int64         `json:"size"`
+	Path         string        `json:"path"`
+	Link         string        `json:"link"`
+	DownloadLink *DownloadLink `json:"-"`
+	AccountId    string        `json:"account_id"`
+	Generated    time.Time     `json:"generated"`
+	Deleted      bool          `json:"deleted"`
 }
 
 func (t *Torrent) Cleanup(remove bool) {
@@ -111,15 +116,6 @@ func (t *Torrent) Cleanup(remove bool) {
 	}
 }
 
-func (t *Torrent) GetFile(id string) *File {
-	for _, f := range t.Files {
-		if f.Id == id {
-			return &f
-		}
-	}
-	return nil
-}
-
 type Account struct {
 	ID       string `json:"id"`
 	Disabled bool   `json:"disabled"`

pkg/qbit/downloader.go

@@ -3,10 +3,10 @@ package qbit
 import (
 	"fmt"
 	"github.com/cavaliergopher/grab/v3"
-	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
-	debrid "github.com/sirrobot01/decypharr/pkg/debrid/types"
+	debridTypes "github.com/sirrobot01/decypharr/pkg/debrid/types"
 	"io"
+	"net/http"
 	"os"
 	"path/filepath"
 	"sync"
@@ -20,7 +20,7 @@ func Download(client *grab.Client, url, filename string, progressCallback func(i
 	}
 	resp := client.Do(req)
 
-	t := time.NewTicker(time.Second)
+	t := time.NewTicker(time.Second * 2)
 	defer t.Stop()
 
 	var lastReported int64
@@ -66,9 +66,9 @@ func (q *QBit) ProcessManualFile(torrent *Torrent) (string, error) {
 func (q *QBit) downloadFiles(torrent *Torrent, parent string) {
 	debridTorrent := torrent.DebridTorrent
 	var wg sync.WaitGroup
-	semaphore := make(chan struct{}, 5)
+
 	totalSize := int64(0)
-	for _, file := range debridTorrent.Files {
+	for _, file := range debridTorrent.GetFiles() {
 		totalSize += file.Size
 	}
 	debridTorrent.Mu.Lock()
@@ -92,36 +92,54 @@ func (q *QBit) downloadFiles(torrent *Torrent, parent string) {
 		q.UpdateTorrentMin(torrent, debridTorrent)
 	}
 	client := &grab.Client{
-		UserAgent:  "qBitTorrent",
-		HTTPClient: request.New(request.WithTimeout(0)),
+		UserAgent: "Decypharr[QBitTorrent]",
+		HTTPClient: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		},
 	}
-	for _, file := range debridTorrent.Files {
-		if file.DownloadLink == "" {
+	errChan := make(chan error, len(debridTorrent.Files))
+	for _, file := range debridTorrent.GetFiles() {
+		if file.DownloadLink == nil {
 			q.logger.Info().Msgf("No download link found for %s", file.Name)
 			continue
 		}
 		wg.Add(1)
-		semaphore <- struct{}{}
-		go func(file debrid.File) {
+		q.downloadSemaphore <- struct{}{}
+		go func(file debridTypes.File) {
 			defer wg.Done()
-			defer func() { <-semaphore }()
-			filename := file.Link
+			defer func() { <-q.downloadSemaphore }()
+			filename := file.Name
 
 			err := Download(
 				client,
-				file.DownloadLink,
+				file.DownloadLink.DownloadLink,
 				filepath.Join(parent, filename),
 				progressCallback,
 			)
 
 			if err != nil {
 				q.logger.Error().Msgf("Failed to download %s: %v", filename, err)
+				errChan <- err
 			} else {
 				q.logger.Info().Msgf("Downloaded %s", filename)
 			}
 		}(file)
 	}
 	wg.Wait()
+
+	close(errChan)
+	var errors []error
+	for err := range errChan {
+		if err != nil {
+			errors = append(errors, err)
+		}
+	}
+	if len(errors) > 0 {
+		q.logger.Error().Msgf("Errors occurred during download: %v", errors)
+		return
+	}
 	q.logger.Info().Msgf("Downloaded all files for %s", debridTorrent.Name)
 }
 
@@ -146,38 +164,62 @@ func (q *QBit) ProcessSymlink(torrent *Torrent) (string, error) {
 		torrentFolder = utils.RemoveExtension(torrentFolder)
 		torrentRclonePath = rCloneBase // /mnt/rclone/magnets/  // Remove the filename since it's in the root folder
 	}
-	return q.createSymlinks(debridTorrent, torrentRclonePath, torrentFolder) // verify cos we're using external webdav
-}
-
-func (q *QBit) createSymlinks(debridTorrent *debrid.Torrent, rclonePath, torrentFolder string) (string, error) {
-	files := debridTorrent.Files
-	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder)
-	err := os.MkdirAll(torrentSymlinkPath, os.ModePerm)
+	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder) // /mnt/symlinks/{category}/MyTVShow/
+	err = os.MkdirAll(torrentSymlinkPath, os.ModePerm)
 	if err != nil {
 		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
 	}
 
-	pending := make(map[string]debrid.File)
+	realPaths := make(map[string]string)
+	err = filepath.WalkDir(torrentRclonePath, func(path string, d os.DirEntry, err error) error {
+		if err != nil {
+			return nil
+		}
+		if !d.IsDir() {
+			filename := d.Name()
+			rel, _ := filepath.Rel(torrentRclonePath, path)
+			realPaths[filename] = rel
+		}
+		return nil
+	})
+	if err != nil {
+		q.logger.Warn().Msgf("Error while scanning rclone path: %v", err)
+	}
+
+	pending := make(map[string]debridTypes.File)
 	for _, file := range files {
+		if realRelPath, ok := realPaths[file.Name]; ok {
+			file.Path = realRelPath
+		}
 		pending[file.Path] = file
 	}
-	ticker := time.NewTicker(100 * time.Millisecond)
+
+	ticker := time.NewTicker(200 * time.Millisecond)
 	defer ticker.Stop()
+	timeout := time.After(30 * time.Minute)
 	filePaths := make([]string, 0, len(pending))
 
 	for len(pending) > 0 {
-		<-ticker.C
-		for path, file := range pending {
-			fullFilePath := filepath.Join(rclonePath, file.Path)
-			if _, err := os.Stat(fullFilePath); !os.IsNotExist(err) {
-				q.logger.Info().Msgf("File is ready: %s", file.Path)
-				_filePath := q.createSymLink(torrentSymlinkPath, rclonePath, file)
-				filePaths = append(filePaths, _filePath)
-				delete(pending, path)
+		select {
+		case <-ticker.C:
+			for path, file := range pending {
+				fullFilePath := filepath.Join(torrentRclonePath, file.Path)
+				if _, err := os.Stat(fullFilePath); !os.IsNotExist(err) {
+					fileSymlinkPath := filepath.Join(torrentSymlinkPath, file.Name)
+					if err := os.Symlink(fullFilePath, fileSymlinkPath); err != nil && !os.IsExist(err) {
+						q.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
+					} else {
+						filePaths = append(filePaths, fileSymlinkPath)
+						delete(pending, path)
+						q.logger.Info().Msgf("File is ready: %s", file.Name)
+					}
+				}
 			}
+		case <-timeout:
+			q.logger.Warn().Msgf("Timeout waiting for files, %d files still pending", len(pending))
+			return torrentSymlinkPath, fmt.Errorf("timeout waiting for files: %d files still pending", len(pending))
 		}
 	}
-
 	if q.SkipPreCache {
 		return torrentSymlinkPath, nil
 	}
@@ -186,13 +228,79 @@ func (q *QBit) createSymlinks(debridTorrent *debrid.Torrent, rclonePath, torrent
 
 		if err := q.preCacheFile(debridTorrent.Name, filePaths); err != nil {
 			q.logger.Error().Msgf("Failed to pre-cache file: %s", err)
+		} else {
+			q.logger.Trace().Msgf("Pre-cached %d files", len(filePaths))
 		}
-	}() // Pre-cache the files in the background
-	// Pre-cache the first 256KB and 1MB of the file
+	}()
 	return torrentSymlinkPath, nil
 }
 
-func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debrid.Torrent) (string, error) {
+func (q *QBit) createSymlinksWebdav(debridTorrent *debridTypes.Torrent, rclonePath, torrentFolder string) (string, error) {
+	files := debridTorrent.Files
+	symlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder) // /mnt/symlinks/{category}/MyTVShow/
+	err := os.MkdirAll(symlinkPath, os.ModePerm)
+	if err != nil {
+		return "", fmt.Errorf("failed to create directory: %s: %v", symlinkPath, err)
+	}
+
+	remainingFiles := make(map[string]debridTypes.File)
+	for _, file := range files {
+		remainingFiles[file.Name] = file
+	}
+
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+	timeout := time.After(30 * time.Minute)
+	filePaths := make([]string, 0, len(files))
+
+	for len(remainingFiles) > 0 {
+		select {
+		case <-ticker.C:
+			entries, err := os.ReadDir(rclonePath)
+			if err != nil {
+				continue
+			}
+
+			// Check which files exist in this batch
+			for _, entry := range entries {
+				filename := entry.Name()
+				if file, exists := remainingFiles[filename]; exists {
+					fullFilePath := filepath.Join(rclonePath, filename)
+					fileSymlinkPath := filepath.Join(symlinkPath, file.Name)
+
+					if err := os.Symlink(fullFilePath, fileSymlinkPath); err != nil && !os.IsExist(err) {
+						q.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
+					} else {
+						filePaths = append(filePaths, fileSymlinkPath)
+						delete(remainingFiles, filename)
+						q.logger.Info().Msgf("File is ready: %s", file.Name)
+					}
+				}
+			}
+
+		case <-timeout:
+			q.logger.Warn().Msgf("Timeout waiting for files, %d files still pending", len(remainingFiles))
+			return symlinkPath, fmt.Errorf("timeout waiting for files")
+		}
+	}
+
+	if q.SkipPreCache {
+		return symlinkPath, nil
+	}
+
+	go func() {
+
+		if err := q.preCacheFile(debridTorrent.Name, filePaths); err != nil {
+			q.logger.Error().Msgf("Failed to pre-cache file: %s", err)
+		} else {
+			q.logger.Debug().Msgf("Pre-cached %d files", len(filePaths))
+		}
+	}() // Pre-cache the files in the background
+	// Pre-cache the first 256KB and 1MB of the file
+	return symlinkPath, nil
+}
+
+func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debridTypes.Torrent) (string, error) {
 	for {
 		torrentPath, err := debridTorrent.GetMountFolder(rclonePath)
 		if err == nil {
@@ -203,47 +311,45 @@ func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debrid.Torrent)
 	}
 }
 
-func (q *QBit) createSymLink(path string, torrentMountPath string, file debrid.File) string {
-
-	// Combine the directory and filename to form a full path
-	fullPath := filepath.Join(path, file.Name) // /mnt/symlinks/{category}/MyTVShow/MyTVShow.S01E01.720p.mkv
-	// Create a symbolic link if file doesn't exist
-	torrentFilePath := filepath.Join(torrentMountPath, file.Path) // debridFolder/MyTVShow/MyTVShow.S01E01.720p.mkv
-	err := os.Symlink(torrentFilePath, fullPath)
-	if err != nil {
-		// It's okay if the symlink already exists
-		q.logger.Debug().Msgf("Failed to create symlink: %s: %v", fullPath, err)
-	}
-	return torrentFilePath
-}
-
 func (q *QBit) preCacheFile(name string, filePaths []string) error {
-	q.logger.Trace().Msgf("Pre-caching file: %s", name)
+	q.logger.Trace().Msgf("Pre-caching torrent: %s", name)
 	if len(filePaths) == 0 {
 		return fmt.Errorf("no file paths provided")
 	}
-	for _, filePath := range filePaths {
-		func() {
-			file, err := os.Open(filePath)
-			defer func(file *os.File) {
-				_ = file.Close()
-			}(file)
-			if err != nil {
-				return
-			}
-			// Pre-cache the file header (first 256KB) using 16KB chunks.
-			q.readSmallChunks(file, 0, 256*1024, 16*1024)
-			q.readSmallChunks(file, 1024*1024, 64*1024, 16*1024)
-		}()
-	}
 
+	for _, filePath := range filePaths {
+		err := func(f string) error {
+
+			file, err := os.Open(f)
+			if err != nil {
+				if os.IsNotExist(err) {
+					// File has probably been moved by arr, return silently
+					return nil
+				}
+				return fmt.Errorf("failed to open file: %s: %v", f, err)
+			}
+			defer file.Close()
+
+			// Pre-cache the file header (first 256KB) using 16KB chunks.
+			if err := q.readSmallChunks(file, 0, 256*1024, 16*1024); err != nil {
+				return err
+			}
+			if err := q.readSmallChunks(file, 1024*1024, 64*1024, 16*1024); err != nil {
+				return err
+			}
+			return nil
+		}(filePath)
+		if err != nil {
+			return err
+		}
+	}
 	return nil
 }
 
-func (q *QBit) readSmallChunks(file *os.File, startPos int64, totalToRead int, chunkSize int) {
+func (q *QBit) readSmallChunks(file *os.File, startPos int64, totalToRead int, chunkSize int) error {
 	_, err := file.Seek(startPos, 0)
 	if err != nil {
-		return
+		return err
 	}
 
 	buf := make([]byte, chunkSize)
@@ -260,9 +366,10 @@ func (q *QBit) readSmallChunks(file *os.File, startPos int64, totalToRead int, c
 			if err == io.EOF {
 				break
 			}
-			return
+			return err
 		}
 
 		bytesRemaining -= n
 	}
+	return nil
 }

pkg/qbit/http.go

@@ -231,7 +231,7 @@ func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 	}
 	category := ctx.Value("category").(string)
 	for _, hash := range hashes {
-		q.Storage.Delete(hash, category)
+		q.Storage.Delete(hash, category, false)
 	}
 
 	w.WriteHeader(http.StatusOK)

pkg/qbit/import.go

@@ -1,7 +1,6 @@
 package qbit
 
 import (
-	"fmt"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
 	"github.com/sirrobot01/decypharr/pkg/service"
@@ -71,16 +70,7 @@ func (i *ImportRequest) Process(q *QBit) (err error) {
 	svc := service.GetService()
 	torrent := createTorrentFromMagnet(i.Magnet, i.Arr.Name, "manual")
 	debridTorrent, err := debrid.ProcessTorrent(svc.Debrid, i.Magnet, i.Arr, i.IsSymlink, i.DownloadUncached)
-	if err != nil || debridTorrent == nil {
-		if debridTorrent != nil {
-			dbClient := service.GetDebrid().GetByName(debridTorrent.Debrid)
-			go func() {
-				_ = dbClient.DeleteTorrent(debridTorrent.Id)
-			}()
-		}
-		if err == nil {
-			err = fmt.Errorf("failed to process torrent")
-		}
+	if err != nil {
 		return err
 	}
 	torrent = q.UpdateTorrentMin(torrent, debridTorrent)

pkg/qbit/misc.go

@@ -1,14 +1,13 @@
 package qbit
 
 import (
-	"github.com/google/uuid"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"strings"
 )
 
 func createTorrentFromMagnet(magnet *utils.Magnet, category, source string) *Torrent {
 	torrent := &Torrent{
-		ID:        uuid.NewString(),
+		ID:        "",
 		Hash:      strings.ToLower(magnet.InfoHash),
 		Name:      magnet.Name,
 		Size:      magnet.Size,

pkg/qbit/qbit.go

@@ -20,22 +20,33 @@ type QBit struct {
 	Tags            []string
 	RefreshInterval int
 	SkipPreCache    bool
+
+	downloadSemaphore chan struct{}
 }
 
 func New() *QBit {
 	_cfg := config.Get()
 	cfg := _cfg.QBitTorrent
-	port := cmp.Or(cfg.Port, os.Getenv("QBIT_PORT"), "8282")
+	port := cmp.Or(_cfg.Port, os.Getenv("QBIT_PORT"), "8282")
 	refreshInterval := cmp.Or(cfg.RefreshInterval, 10)
 	return &QBit{
-		Username:        cfg.Username,
-		Password:        cfg.Password,
-		Port:            port,
-		DownloadFolder:  cfg.DownloadFolder,
-		Categories:      cfg.Categories,
-		Storage:         NewTorrentStorage(filepath.Join(_cfg.Path, "torrents.json")),
-		logger:          logger.New("qbit"),
-		RefreshInterval: refreshInterval,
-		SkipPreCache:    cfg.SkipPreCache,
+		Username:          cfg.Username,
+		Password:          cfg.Password,
+		Port:              port,
+		DownloadFolder:    cfg.DownloadFolder,
+		Categories:        cfg.Categories,
+		Storage:           NewTorrentStorage(filepath.Join(_cfg.Path, "torrents.json")),
+		logger:            logger.New("qbit"),
+		RefreshInterval:   refreshInterval,
+		SkipPreCache:      cfg.SkipPreCache,
+		downloadSemaphore: make(chan struct{}, cmp.Or(cfg.MaxDownloads, 5)),
 	}
 }
+
+func (q *QBit) Reset() {
+	if q.Storage != nil {
+		q.Storage.Reset()
+	}
+	q.Tags = nil
+	close(q.downloadSemaphore)
+}

pkg/qbit/storage.go

@@ -1,8 +1,9 @@
 package qbit
 
 import (
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
+	"github.com/sirrobot01/decypharr/pkg/service"
 	"os"
 	"sort"
 	"sync"
@@ -166,7 +167,7 @@ func (ts *TorrentStorage) Update(torrent *Torrent) {
 	}()
 }
 
-func (ts *TorrentStorage) Delete(hash, category string) {
+func (ts *TorrentStorage) Delete(hash, category string, removeFromDebrid bool) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
 	key := keyPair(hash, category)
@@ -181,10 +182,22 @@ func (ts *TorrentStorage) Delete(hash, category string) {
 			}
 		}
 	}
-	delete(ts.torrents, key)
+
 	if torrent == nil {
 		return
 	}
+	if removeFromDebrid && torrent.ID != "" && torrent.Debrid != "" {
+		dbClient := service.GetDebrid().GetClient(torrent.Debrid)
+		if dbClient != nil {
+			err := dbClient.DeleteTorrent(torrent.ID)
+			if err != nil {
+				fmt.Println(err)
+			}
+		}
+	}
+
+	delete(ts.torrents, key)
+
 	// Delete the torrent folder
 	if torrent.ContentPath != "" {
 		err := os.RemoveAll(torrent.ContentPath)
@@ -200,13 +213,27 @@ func (ts *TorrentStorage) Delete(hash, category string) {
 	}()
 }
 
-func (ts *TorrentStorage) DeleteMultiple(hashes []string) {
+func (ts *TorrentStorage) DeleteMultiple(hashes []string, removeFromDebrid bool) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
+	toDelete := make(map[string]string)
+
 	for _, hash := range hashes {
 		for key, torrent := range ts.torrents {
+			if torrent == nil {
+				continue
+			}
 			if torrent.Hash == hash {
+				if removeFromDebrid && torrent.ID != "" && torrent.Debrid != "" {
+					toDelete[torrent.ID] = torrent.Debrid
+				}
 				delete(ts.torrents, key)
+				if torrent.ContentPath != "" {
+					err := os.RemoveAll(torrent.ContentPath)
+					if err != nil {
+						return
+					}
+				}
 			}
 		}
 	}
@@ -216,6 +243,19 @@ func (ts *TorrentStorage) DeleteMultiple(hashes []string) {
 			fmt.Println(err)
 		}
 	}()
+
+	go func() {
+		for id, debrid := range toDelete {
+			dbClient := service.GetDebrid().GetClient(debrid)
+			if dbClient == nil {
+				continue
+			}
+			err := dbClient.DeleteTorrent(id)
+			if err != nil {
+				fmt.Println(err)
+			}
+		}
+	}()
 }
 
 func (ts *TorrentStorage) Save() error {
@@ -232,3 +272,9 @@ func (ts *TorrentStorage) saveToFile() error {
 	}
 	return os.WriteFile(ts.filename, data, 0644)
 }
+
+func (ts *TorrentStorage) Reset() {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	ts.torrents = make(Torrents)
+}

pkg/qbit/torrent.go

@@ -7,14 +7,13 @@ import (
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/arr"
-	db "github.com/sirrobot01/decypharr/pkg/debrid/debrid"
-	debrid "github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
+	debridTypes "github.com/sirrobot01/decypharr/pkg/debrid/types"
 	"github.com/sirrobot01/decypharr/pkg/service"
 	"io"
 	"mime/multipart"
 	"os"
 	"path/filepath"
-	"slices"
 	"strings"
 	"time"
 )
@@ -56,14 +55,8 @@ func (q *QBit) Process(ctx context.Context, magnet *utils.Magnet, category strin
 		return fmt.Errorf("arr not found in context")
 	}
 	isSymlink := ctx.Value("isSymlink").(bool)
-	debridTorrent, err := db.ProcessTorrent(svc.Debrid, magnet, a, isSymlink, false)
+	debridTorrent, err := debrid.ProcessTorrent(svc.Debrid, magnet, a, isSymlink, false)
 	if err != nil || debridTorrent == nil {
-		if debridTorrent != nil {
-			dbClient := service.GetDebrid().GetByName(debridTorrent.Debrid)
-			go func() {
-				_ = dbClient.DeleteTorrent(debridTorrent.Id)
-			}()
-		}
 		if err == nil {
 			err = fmt.Errorf("failed to process torrent")
 		}
@@ -75,24 +68,27 @@ func (q *QBit) Process(ctx context.Context, magnet *utils.Magnet, category strin
 	return nil
 }
 
-func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr *arr.Arr, isSymlink bool) {
+func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debridTypes.Torrent, arr *arr.Arr, isSymlink bool) {
 	svc := service.GetService()
-	client := svc.Debrid.GetByName(debridTorrent.Debrid)
+	client := svc.Debrid.GetClient(debridTorrent.Debrid)
+	downloadingStatuses := client.GetDownloadingStatus()
 	for debridTorrent.Status != "downloaded" {
 		q.logger.Debug().Msgf("%s <- (%s) Download Progress: %.2f%%", debridTorrent.Debrid, debridTorrent.Name, debridTorrent.Progress)
 		dbT, err := client.CheckStatus(debridTorrent, isSymlink)
 		if err != nil {
+			if dbT != nil && dbT.Id != "" {
+				// Delete the torrent if it was not downloaded
+				go func() {
+					_ = client.DeleteTorrent(dbT.Id)
+				}()
+			}
 			q.logger.Error().Msgf("Error checking status: %v", err)
+			q.MarkAsFailed(torrent)
 			go func() {
-				err := client.DeleteTorrent(debridTorrent.Id)
-				if err != nil {
-					q.logger.Error().Msgf("Error deleting torrent: %v", err)
+				if err := arr.Refresh(); err != nil {
+					q.logger.Error().Msgf("Error refreshing arr: %v", err)
 				}
 			}()
-			q.MarkAsFailed(torrent)
-			if err := arr.Refresh(); err != nil {
-				q.logger.Error().Msgf("Error refreshing arr: %v", err)
-			}
 			return
 		}
 
@@ -100,33 +96,36 @@ func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr
 		torrent = q.UpdateTorrentMin(torrent, debridTorrent)
 
 		// Exit the loop for downloading statuses to prevent memory buildup
-		if !slices.Contains(client.GetDownloadingStatus(), debridTorrent.Status) {
+		if debridTorrent.Status == "downloaded" || !utils.Contains(downloadingStatuses, debridTorrent.Status) {
+			break
+		}
+		if !utils.Contains(client.GetDownloadingStatus(), debridTorrent.Status) {
 			break
 		}
 		time.Sleep(time.Duration(q.RefreshInterval) * time.Second)
 	}
-	var (
-		torrentSymlinkPath string
-		err                error
-	)
+	var torrentSymlinkPath string
+	var err error
 	debridTorrent.Arr = arr
 
-	// File is done downloading at this stage
-
 	// Check if debrid supports webdav by checking cache
+	timer := time.Now()
 	if isSymlink {
-		cache, ok := svc.Debrid.Caches[debridTorrent.Debrid]
-		if ok {
+		cache, useWebdav := svc.Debrid.Caches[debridTorrent.Debrid]
+		if useWebdav {
 			q.logger.Info().Msgf("Using internal webdav for %s", debridTorrent.Debrid)
+
 			// Use webdav to download the file
+
 			if err := cache.AddTorrent(debridTorrent); err != nil {
 				q.logger.Error().Msgf("Error adding torrent to cache: %v", err)
 				q.MarkAsFailed(torrent)
 				return
 			}
+
 			rclonePath := filepath.Join(debridTorrent.MountPath, cache.GetTorrentFolder(debridTorrent)) // /mnt/remote/realdebrid/MyTVShow
 			torrentFolderNoExt := utils.RemoveExtension(debridTorrent.Name)
-			torrentSymlinkPath, err = q.createSymlinks(debridTorrent, rclonePath, torrentFolderNoExt) // /mnt/symlinks/{category}/MyTVShow/
+			torrentSymlinkPath, err = q.createSymlinksWebdav(debridTorrent, rclonePath, torrentFolderNoExt) // /mnt/symlinks/{category}/MyTVShow/
 
 		} else {
 			// User is using either zurg or debrid webdav
@@ -138,16 +137,14 @@ func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr
 	if err != nil {
 		q.MarkAsFailed(torrent)
 		go func() {
-			err := client.DeleteTorrent(debridTorrent.Id)
-			if err != nil {
-				q.logger.Error().Msgf("Error deleting torrent: %v", err)
-			}
+			_ = client.DeleteTorrent(debridTorrent.Id)
 		}()
 		q.logger.Info().Msgf("Error: %v", err)
 		return
 	}
 	torrent.TorrentPath = torrentSymlinkPath
 	q.UpdateTorrent(torrent, debridTorrent)
+	q.logger.Info().Msgf("Adding %s took %s", debridTorrent.Name, time.Since(timer))
 	go func() {
 		if err := request.SendDiscordMessage("download_complete", "success", torrent.discordContext()); err != nil {
 			q.logger.Error().Msgf("Error sending discord message: %v", err)
@@ -169,7 +166,7 @@ func (q *QBit) MarkAsFailed(t *Torrent) *Torrent {
 	return t
 }
 
-func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
+func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debridTypes.Torrent) *Torrent {
 	if debridTorrent == nil {
 		return t
 	}
@@ -179,8 +176,7 @@ func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torr
 		addedOn = time.Now()
 	}
 	totalSize := debridTorrent.Bytes
-	progress := cmp.Or(debridTorrent.Progress, 100)
-	progress = progress / 100.0
+	progress := (cmp.Or(debridTorrent.Progress, 0.0)) / 100.0
 	sizeCompleted := int64(float64(totalSize) * progress)
 
 	var speed int64
@@ -212,13 +208,15 @@ func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torr
 	return t
 }
 
-func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
+func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debridTypes.Torrent) *Torrent {
 	if debridTorrent == nil {
 		return t
 	}
-	_db := service.GetDebrid().GetByName(debridTorrent.Debrid)
-	if debridTorrent.Status != "downloaded" {
-		_ = _db.UpdateTorrent(debridTorrent)
+
+	if debridClient := service.GetDebrid().GetClient(debridTorrent.Debrid); debridClient != nil {
+		if debridTorrent.Status != "downloaded" {
+			_ = debridClient.UpdateTorrent(debridTorrent)
+		}
 	}
 	t = q.UpdateTorrentMin(t, debridTorrent)
 	t.ContentPath = t.TorrentPath + string(os.PathSeparator)
@@ -291,7 +289,7 @@ func (q *QBit) GetTorrentFiles(t *Torrent) []*TorrentFile {
 	if t.DebridTorrent == nil {
 		return files
 	}
-	for _, file := range t.DebridTorrent.Files {
+	for _, file := range t.DebridTorrent.GetFiles() {
 		files = append(files, &TorrentFile{
 			Name: file.Path,
 			Size: file.Size,
@@ -306,10 +304,10 @@ func (q *QBit) SetTorrentTags(t *Torrent, tags []string) bool {
 		if tag == "" {
 			continue
 		}
-		if !slices.Contains(torrentTags, tag) {
+		if !utils.Contains(torrentTags, tag) {
 			torrentTags = append(torrentTags, tag)
 		}
-		if !slices.Contains(q.Tags, tag) {
+		if !utils.Contains(q.Tags, tag) {
 			q.Tags = append(q.Tags, tag)
 		}
 	}
@@ -332,7 +330,7 @@ func (q *QBit) AddTags(tags []string) bool {
 		if tag == "" {
 			continue
 		}
-		if !slices.Contains(q.Tags, tag) {
+		if !utils.Contains(q.Tags, tag) {
 			q.Tags = append(q.Tags, tag)
 		}
 	}

pkg/qbit/types.go

@@ -228,7 +228,7 @@ type Torrent struct {
 }
 
 func (t *Torrent) IsReady() bool {
-	return t.AmountLeft <= 0 && t.TorrentPath != ""
+	return (t.AmountLeft <= 0 || t.Progress == 1) && t.TorrentPath != ""
 }
 
 func (t *Torrent) discordContext() string {

pkg/repair/misc.go

@@ -5,73 +5,8 @@ import (
 	"github.com/sirrobot01/decypharr/pkg/arr"
 	"os"
 	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
 )
 
-func parseSchedule(schedule string) (time.Duration, error) {
-	if schedule == "" {
-		return time.Hour, nil // default 60m
-	}
-
-	// Check if it's a time-of-day format (HH:MM)
-	if strings.Contains(schedule, ":") {
-		return parseTimeOfDay(schedule)
-	}
-
-	// Otherwise treat as duration interval
-	return parseDurationInterval(schedule)
-}
-
-func parseTimeOfDay(schedule string) (time.Duration, error) {
-	now := time.Now()
-	scheduledTime, err := time.Parse("15:04", schedule)
-	if err != nil {
-		return 0, fmt.Errorf("invalid time format: %s. Use HH:MM in 24-hour format", schedule)
-	}
-
-	// Convert scheduled time to today
-	scheduleToday := time.Date(
-		now.Year(), now.Month(), now.Day(),
-		scheduledTime.Hour(), scheduledTime.Minute(), 0, 0,
-		now.Location(),
-	)
-
-	if scheduleToday.Before(now) {
-		scheduleToday = scheduleToday.Add(24 * time.Hour)
-	}
-
-	return scheduleToday.Sub(now), nil
-}
-
-func parseDurationInterval(interval string) (time.Duration, error) {
-	if len(interval) < 2 {
-		return 0, fmt.Errorf("invalid interval format: %s", interval)
-	}
-
-	numStr := interval[:len(interval)-1]
-	unit := interval[len(interval)-1]
-
-	num, err := strconv.Atoi(numStr)
-	if err != nil {
-		return 0, fmt.Errorf("invalid number in interval: %s", numStr)
-	}
-
-	switch unit {
-	case 'm':
-		return time.Duration(num) * time.Minute, nil
-	case 'h':
-		return time.Duration(num) * time.Hour, nil
-	case 'd':
-		return time.Duration(num) * 24 * time.Hour, nil
-	case 's':
-		return time.Duration(num) * time.Second, nil
-	default:
-		return 0, fmt.Errorf("invalid unit in interval: %c", unit)
-	}
-}
-
 func fileIsSymlinked(file string) bool {
 	info, err := os.Lstat(file)
 	if err != nil {

pkg/repair/repair.go

@@ -2,13 +2,15 @@ package repair
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
-	"github.com/goccy/go-json"
+	"github.com/go-co-op/gocron/v2"
 	"github.com/google/uuid"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/internal/request"
+	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/arr"
 	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
 	"golang.org/x/sync/errgroup"
@@ -28,7 +30,7 @@ type Repair struct {
 	Jobs        map[string]*Job
 	arrs        *arr.Storage
 	deb         *debrid.Engine
-	duration    time.Duration
+	interval    string
 	runOnStart  bool
 	ZurgURL     string
 	IsZurg      bool
@@ -37,79 +39,10 @@ type Repair struct {
 	logger      zerolog.Logger
 	filename    string
 	workers     int
+	scheduler   gocron.Scheduler
 	ctx         context.Context
 }
 
-func New(arrs *arr.Storage, engine *debrid.Engine) *Repair {
-	cfg := config.Get()
-	duration, err := parseSchedule(cfg.Repair.Interval)
-	if err != nil {
-		duration = time.Hour * 24
-	}
-	workers := runtime.NumCPU() * 20
-	if cfg.Repair.Workers > 0 {
-		workers = cfg.Repair.Workers
-	}
-	r := &Repair{
-		arrs:        arrs,
-		logger:      logger.New("repair"),
-		duration:    duration,
-		runOnStart:  cfg.Repair.RunOnStart,
-		ZurgURL:     cfg.Repair.ZurgURL,
-		useWebdav:   cfg.Repair.UseWebDav,
-		autoProcess: cfg.Repair.AutoProcess,
-		filename:    filepath.Join(cfg.Path, "repair.json"),
-		deb:         engine,
-		workers:     workers,
-		ctx:         context.Background(),
-	}
-	if r.ZurgURL != "" {
-		r.IsZurg = true
-	}
-	// Load jobs from file
-	r.loadFromFile()
-
-	return r
-}
-
-func (r *Repair) Start(ctx context.Context) error {
-	cfg := config.Get()
-	r.ctx = ctx
-	if r.runOnStart {
-		r.logger.Info().Msgf("Running initial repair")
-		go func() {
-			if err := r.AddJob([]string{}, []string{}, r.autoProcess, true); err != nil {
-				r.logger.Error().Err(err).Msg("Error running initial repair")
-			}
-		}()
-	}
-
-	ticker := time.NewTicker(r.duration)
-	defer ticker.Stop()
-
-	r.logger.Info().Msgf("Starting repair worker with %v interval", r.duration)
-
-	for {
-		select {
-		case <-r.ctx.Done():
-			r.logger.Info().Msg("Repair worker stopped")
-			return nil
-		case t := <-ticker.C:
-			r.logger.Info().Msgf("Running repair at %v", t.Format("15:04:05"))
-			if err := r.AddJob([]string{}, []string{}, r.autoProcess, true); err != nil {
-				r.logger.Error().Err(err).Msg("Error running repair")
-			}
-
-			// If using time-of-day schedule, reset the ticker for next day
-			if strings.Contains(cfg.Repair.Interval, ":") {
-				ticker.Reset(r.duration)
-			}
-
-			r.logger.Info().Msgf("Next scheduled repair at %v", t.Add(r.duration).Format("15:04:05"))
-		}
-	}
-}
-
 type JobStatus string
 
 const (
@@ -135,6 +68,88 @@ type Job struct {
 	Error string `json:"error"`
 }
 
+func New(arrs *arr.Storage, engine *debrid.Engine) *Repair {
+	cfg := config.Get()
+	workers := runtime.NumCPU() * 20
+	if cfg.Repair.Workers > 0 {
+		workers = cfg.Repair.Workers
+	}
+	r := &Repair{
+		arrs:        arrs,
+		logger:      logger.New("repair"),
+		interval:    cfg.Repair.Interval,
+		runOnStart:  cfg.Repair.RunOnStart,
+		ZurgURL:     cfg.Repair.ZurgURL,
+		useWebdav:   cfg.Repair.UseWebDav,
+		autoProcess: cfg.Repair.AutoProcess,
+		filename:    filepath.Join(cfg.Path, "repair.json"),
+		deb:         engine,
+		workers:     workers,
+		ctx:         context.Background(),
+	}
+	if r.ZurgURL != "" {
+		r.IsZurg = true
+	}
+	// Load jobs from file
+	r.loadFromFile()
+
+	return r
+}
+
+func (r *Repair) Reset() {
+	// Stop scheduler
+	if r.scheduler != nil {
+		if err := r.scheduler.StopJobs(); err != nil {
+			r.logger.Error().Err(err).Msg("Error stopping scheduler")
+		}
+
+		if err := r.scheduler.Shutdown(); err != nil {
+			r.logger.Error().Err(err).Msg("Error shutting down scheduler")
+		}
+	}
+	// Reset jobs
+	r.Jobs = make(map[string]*Job)
+
+}
+
+func (r *Repair) Start(ctx context.Context) error {
+	//r.ctx = ctx
+	if r.runOnStart {
+		r.logger.Info().Msgf("Running initial repair")
+		go func() {
+			if err := r.AddJob([]string{}, []string{}, r.autoProcess, true); err != nil {
+				r.logger.Error().Err(err).Msg("Error running initial repair")
+			}
+		}()
+	}
+
+	r.scheduler, _ = gocron.NewScheduler(gocron.WithLocation(time.Local))
+
+	if jd, err := utils.ConvertToJobDef(r.interval); err != nil {
+		r.logger.Error().Err(err).Str("interval", r.interval).Msg("Error converting interval")
+	} else {
+		_, err2 := r.scheduler.NewJob(jd, gocron.NewTask(func() {
+			r.logger.Info().Msgf("Repair job started at %s", time.Now().Format("15:04:05"))
+			if err := r.AddJob([]string{}, []string{}, r.autoProcess, true); err != nil {
+				r.logger.Error().Err(err).Msg("Error running repair job")
+			}
+		}))
+		if err2 != nil {
+			r.logger.Error().Err(err2).Msg("Error creating repair job")
+		} else {
+			r.scheduler.Start()
+			r.logger.Info().Msgf("Repair job scheduled every %s", r.interval)
+		}
+	}
+
+	<-ctx.Done()
+
+	r.logger.Info().Msg("Stopping repair scheduler")
+	r.Reset()
+
+	return nil
+}
+
 func (j *Job) discordContext() string {
 	format := `
 		**ID**: %s
@@ -217,7 +232,7 @@ func (r *Repair) preRunChecks() error {
 	}
 	resp, err := http.Get(fmt.Sprint(r.ZurgURL, "/http/version.txt"))
 	if err != nil {
-		r.logger.Debug().Err(err).Msgf("Precheck failed: Failed to reach zurg at %s", r.ZurgURL)
+		r.logger.Error().Err(err).Msgf("Precheck failed: Failed to reach zurg at %s", r.ZurgURL)
 		return err
 	}
 	if resp.StatusCode != http.StatusOK {
@@ -477,15 +492,14 @@ func (r *Repair) getFileBrokenFiles(media arr.Content) []arr.ContentFile {
 
 	uniqueParents := collectFiles(media)
 
-	for parent, f := range uniqueParents {
+	for parent, files := range uniqueParents {
 		// Check stat
 		// Check file stat first
-		firstFile := f[0]
-		// Read a tiny bit of the file
-		if err := fileIsReadable(firstFile.Path); err != nil {
-			r.logger.Debug().Msgf("Broken file found at: %s", parent)
-			brokenFiles = append(brokenFiles, f...)
-			continue
+		for _, file := range files {
+			if err := fileIsReadable(file.Path); err != nil {
+				r.logger.Debug().Msgf("Broken file found at: %s", parent)
+				brokenFiles = append(brokenFiles, file)
+			}
 		}
 	}
 	if len(brokenFiles) == 0 {
@@ -511,41 +525,44 @@ func (r *Repair) getZurgBrokenFiles(media arr.Content) []arr.ContentFile {
 	}
 	client := request.New(request.WithTimeout(0), request.WithTransport(tr))
 	// Access zurg url + symlink folder + first file(encoded)
-	for parent, f := range uniqueParents {
+	for parent, files := range uniqueParents {
 		r.logger.Debug().Msgf("Checking %s", parent)
 		torrentName := url.PathEscape(filepath.Base(parent))
-		encodedFile := url.PathEscape(f[0].TargetPath)
-		fullURL := fmt.Sprintf("%s/http/__all__/%s/%s", r.ZurgURL, torrentName, encodedFile)
-		// Check file stat first
-		if _, err := os.Stat(f[0].Path); os.IsNotExist(err) {
-			r.logger.Debug().Msgf("Broken symlink found: %s", fullURL)
-			brokenFiles = append(brokenFiles, f...)
+
+		if len(files) == 0 {
+			r.logger.Debug().Msgf("No files found for %s. Skipping", torrentName)
 			continue
 		}
 
-		resp, err := client.Get(fullURL)
-		if err != nil {
-			r.logger.Debug().Err(err).Msgf("Failed to reach %s", fullURL)
-			brokenFiles = append(brokenFiles, f...)
-			continue
-		}
-
-		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-			r.logger.Debug().Msgf("Failed to get download url for %s", fullURL)
+		for _, file := range files {
+			encodedFile := url.PathEscape(file.TargetPath)
+			fullURL := fmt.Sprintf("%s/http/__all__/%s/%s", r.ZurgURL, torrentName, encodedFile)
+			if _, err := os.Stat(file.Path); os.IsNotExist(err) {
+				r.logger.Debug().Msgf("Broken symlink found: %s", fullURL)
+				brokenFiles = append(brokenFiles, file)
+				continue
+			}
+			resp, err := client.Get(fullURL)
+			if err != nil {
+				r.logger.Error().Err(err).Msgf("Failed to reach %s", fullURL)
+				brokenFiles = append(brokenFiles, file)
+				continue
+			}
+			if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+				r.logger.Debug().Msgf("Failed to get download url for %s", fullURL)
+				resp.Body.Close()
+				brokenFiles = append(brokenFiles, file)
+				continue
+			}
+			downloadUrl := resp.Request.URL.String()
 			resp.Body.Close()
-			brokenFiles = append(brokenFiles, f...)
-			continue
-		}
-
-		downloadUrl := resp.Request.URL.String()
-		resp.Body.Close()
-
-		if downloadUrl != "" {
-			r.logger.Trace().Msgf("Found download url: %s", downloadUrl)
-		} else {
-			r.logger.Debug().Msgf("Failed to get download url for %s", fullURL)
-			brokenFiles = append(brokenFiles, f...)
-			continue
+			if downloadUrl != "" {
+				r.logger.Trace().Msgf("Found download url: %s", downloadUrl)
+			} else {
+				r.logger.Debug().Msgf("Failed to get download url for %s", fullURL)
+				brokenFiles = append(brokenFiles, file)
+				continue
+			}
 		}
 	}
 	if len(brokenFiles) == 0 {
@@ -573,7 +590,6 @@ func (r *Repair) getWebdavBrokenFiles(media arr.Content) []arr.ContentFile {
 
 	brokenFiles := make([]arr.ContentFile, 0)
 	uniqueParents := collectFiles(media)
-	// Access zurg url + symlink folder + first file(encoded)
 	for torrentPath, f := range uniqueParents {
 		r.logger.Debug().Msgf("Checking %s", torrentPath)
 		// Get the debrid first
@@ -604,6 +620,7 @@ func (r *Repair) getWebdavBrokenFiles(media arr.Content) []arr.ContentFile {
 		torrent := cache.GetTorrentByName(torrentName)
 		if torrent == nil {
 			r.logger.Debug().Msgf("No torrent found for %s. Skipping", torrentName)
+			brokenFiles = append(brokenFiles, f...)
 			continue
 		}
 		files := make([]string, 0)
@@ -611,11 +628,15 @@ func (r *Repair) getWebdavBrokenFiles(media arr.Content) []arr.ContentFile {
 			files = append(files, file.TargetPath)
 		}
 
-		if cache.IsTorrentBroken(torrent, files) {
-			r.logger.Debug().Msgf("[webdav] Broken symlink found: %s", torrentPath)
-			// Delete the torrent?
-			brokenFiles = append(brokenFiles, f...)
-			continue
+		_brokenFiles := cache.GetBrokenFiles(torrent, files)
+		totalBrokenFiles := len(_brokenFiles)
+		if totalBrokenFiles > 0 {
+			r.logger.Debug().Msgf("%d broken files found in %s", totalBrokenFiles, torrentName)
+			for _, contentFile := range f {
+				if utils.Contains(_brokenFiles, contentFile.TargetPath) {
+					brokenFiles = append(brokenFiles, contentFile)
+				}
+			}
 		}
 
 	}
@@ -736,7 +757,7 @@ func (r *Repair) saveToFile() {
 	// Save jobs to file
 	data, err := json.Marshal(r.Jobs)
 	if err != nil {
-		r.logger.Debug().Err(err).Msg("Failed to marshal jobs")
+		r.logger.Error().Err(err).Msg("Failed to marshal jobs")
 	}
 	_ = os.WriteFile(r.filename, data, 0644)
 }
@@ -750,7 +771,7 @@ func (r *Repair) loadFromFile() {
 	_jobs := make(map[string]*Job)
 	err = json.Unmarshal(data, &_jobs)
 	if err != nil {
-		r.logger.Trace().Err(err).Msg("Failed to unmarshal jobs; resetting")
+		r.logger.Error().Err(err).Msg("Failed to unmarshal jobs; resetting")
 		r.Jobs = make(map[string]*Job)
 		return
 	}
@@ -778,3 +799,12 @@ func (r *Repair) DeleteJobs(ids []string) {
 	}
 	go r.saveToFile()
 }
+
+// Cleanup Cleans up the repair instance
+func (r *Repair) Cleanup() {
+	r.Jobs = make(map[string]*Job)
+	r.arrs = nil
+	r.deb = nil
+	r.ctx = nil
+	r.logger.Info().Msg("Repair stopped")
+}

pkg/server/server.go

@@ -6,16 +6,15 @@ import (
 	"fmt"
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
-	"github.com/goccy/go-json"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
+	"github.com/sirrobot01/decypharr/internal/request"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
-	"os/signal"
 	"runtime"
-	"syscall"
 )
 
 type Server struct {
@@ -23,41 +22,53 @@ type Server struct {
 	logger zerolog.Logger
 }
 
-func New() *Server {
+func New(handlers map[string]http.Handler) *Server {
 	l := logger.New("http")
 	r := chi.NewRouter()
 	r.Use(middleware.Recoverer)
-	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
 
-	return &Server{
-		router: r,
+	cfg := config.Get()
+
+	s := &Server{
 		logger: l,
 	}
+	staticPath, _ := url.JoinPath(cfg.URLBase, "static")
+	r.Handle(staticPath+"/*",
+		http.StripPrefix(staticPath, http.FileServer(http.Dir("static"))),
+	)
+
+	r.Route(cfg.URLBase, func(r chi.Router) {
+		for pattern, handler := range handlers {
+			r.Mount(pattern, handler)
+		}
+
+		//logs
+		r.Get("/logs", s.getLogs)
+
+		//stats
+		r.Get("/stats", s.getStats)
+
+		//webhooks
+		r.Post("/webhooks/tautulli", s.handleTautulli)
+
+	})
+	s.router = r
+	return s
 }
 
 func (s *Server) Start(ctx context.Context) error {
 	cfg := config.Get()
-	// Register routes
-	// Register webhooks
-	s.router.Post("/webhooks/tautulli", s.handleTautulli)
 
-	// Register logs
-	s.router.Get("/logs", s.getLogs)
-	s.router.Get("/stats", s.getStats)
-	port := fmt.Sprintf(":%s", cfg.QBitTorrent.Port)
-	s.logger.Info().Msgf("Server started on %s", port)
+	addr := fmt.Sprintf("%s:%s", cfg.BindAddress, cfg.Port)
+	s.logger.Info().Msgf("Starting server on %s%s", addr, cfg.URLBase)
 	srv := &http.Server{
-		Addr:    port,
+		Addr:    addr,
 		Handler: s.router,
 	}
 
-	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
-	defer stop()
-
 	go func() {
 		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
 			s.logger.Info().Msgf("Error starting server: %v", err)
-			stop()
 		}
 	}()
 
@@ -66,14 +77,6 @@ func (s *Server) Start(ctx context.Context) error {
 	return srv.Shutdown(context.Background())
 }
 
-func (s *Server) AddRoutes(routes func(r chi.Router) http.Handler) {
-	routes(s.router)
-}
-
-func (s *Server) Mount(pattern string, handler http.Handler) {
-	s.router.Mount(pattern, handler)
-}
-
 func (s *Server) getLogs(w http.ResponseWriter, r *http.Request) {
 	logFile := logger.GetLogPath()
 
@@ -86,7 +89,7 @@ func (s *Server) getLogs(w http.ResponseWriter, r *http.Request) {
 	defer func(file *os.File) {
 		err := file.Close()
 		if err != nil {
-			s.logger.Debug().Err(err).Msg("Error closing log file")
+			s.logger.Error().Err(err).Msg("Error closing log file")
 		}
 	}(file)
 
@@ -100,7 +103,7 @@ func (s *Server) getLogs(w http.ResponseWriter, r *http.Request) {
 	// Stream the file
 	_, err = io.Copy(w, file)
 	if err != nil {
-		s.logger.Debug().Err(err).Msg("Error streaming log file")
+		s.logger.Error().Err(err).Msg("Error streaming log file")
 		http.Error(w, "Error streaming log file", http.StatusInternalServerError)
 		return
 	}
@@ -114,7 +117,7 @@ func (s *Server) getStats(w http.ResponseWriter, r *http.Request) {
 		// Memory stats
 		"heap_alloc_mb":  fmt.Sprintf("%.2fMB", float64(memStats.HeapAlloc)/1024/1024),
 		"total_alloc_mb": fmt.Sprintf("%.2fMB", float64(memStats.TotalAlloc)/1024/1024),
-		"sys_mb":         fmt.Sprintf("%.2fMB", float64(memStats.Sys)/1024/1024),
+		"memory_used":    fmt.Sprintf("%.2fMB", float64(memStats.Sys)/1024/1024),
 
 		// GC stats
 		"gc_cycles": memStats.NumGC,
@@ -123,11 +126,11 @@ func (s *Server) getStats(w http.ResponseWriter, r *http.Request) {
 
 		// System info
 		"num_cpu": runtime.NumCPU(),
-	}
 
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	if err := json.NewEncoder(w).Encode(stats); err != nil {
-		s.logger.Error().Err(err).Msg("Failed to encode stats")
+		// OS info
+		"os":         runtime.GOOS,
+		"arch":       runtime.GOARCH,
+		"go_version": runtime.Version(),
 	}
+	request.JSONResponse(w, stats, http.StatusOK)
 }

pkg/server/webhook.go

@@ -2,7 +2,7 @@ package server
 
 import (
 	"cmp"
-	"github.com/goccy/go-json"
+	"encoding/json"
 	"github.com/sirrobot01/decypharr/pkg/service"
 	"net/http"
 )

pkg/service/service.go

@@ -18,7 +18,8 @@ var (
 	once     sync.Once
 )
 
-func New() *Service {
+// GetService returns the singleton instance
+func GetService() *Service {
 	once.Do(func() {
 		arrs := arr.NewStorage()
 		deb := debrid.NewEngine()
@@ -31,23 +32,20 @@ func New() *Service {
 	return instance
 }
 
-// GetService returns the singleton instance
-func GetService() *Service {
-	if instance == nil {
-		instance = New()
+func Reset() {
+	if instance != nil {
+		if instance.Debrid != nil {
+			instance.Debrid.Reset()
+		}
+		if instance.Arr != nil {
+			//instance.Arr.Reset()
+		}
+		if instance.Repair != nil {
+			//instance.Repair.Reset()
+		}
 	}
-	return instance
-}
-
-func Update() *Service {
-	arrs := arr.NewStorage()
-	deb := debrid.NewEngine()
-	instance = &Service{
-		Repair: repair.New(arrs, deb),
-		Arr:    arrs,
-		Debrid: deb,
-	}
-	return instance
+	once = sync.Once{}
+	instance = nil
 }
 
 func GetDebrid() *debrid.Engine {

pkg/web/api.go

@@ -0,0 +1,301 @@
+package web
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"encoding/json"
+	"github.com/go-chi/chi/v5"
+	"github.com/sirrobot01/decypharr/internal/config"
+	"github.com/sirrobot01/decypharr/internal/request"
+	"github.com/sirrobot01/decypharr/internal/utils"
+	"github.com/sirrobot01/decypharr/pkg/arr"
+	"github.com/sirrobot01/decypharr/pkg/qbit"
+	"github.com/sirrobot01/decypharr/pkg/service"
+	"github.com/sirrobot01/decypharr/pkg/version"
+)
+
+func (ui *Handler) handleGetArrs(w http.ResponseWriter, r *http.Request) {
+	svc := service.GetService()
+	request.JSONResponse(w, svc.Arr.GetAll(), http.StatusOK)
+}
+
+func (ui *Handler) handleAddContent(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	svc := service.GetService()
+
+	results := make([]*qbit.ImportRequest, 0)
+	errs := make([]string, 0)
+
+	arrName := r.FormValue("arr")
+	notSymlink := r.FormValue("notSymlink") == "true"
+	downloadUncached := r.FormValue("downloadUncached") == "true"
+	if arrName == "" {
+		arrName = "uncategorized"
+	}
+
+	_arr := svc.Arr.Get(arrName)
+	if _arr == nil {
+		_arr = arr.New(arrName, "", "", false, false, &downloadUncached)
+	}
+
+	// Handle URLs
+	if urls := r.FormValue("urls"); urls != "" {
+		var urlList []string
+		for _, u := range strings.Split(urls, "\n") {
+			if trimmed := strings.TrimSpace(u); trimmed != "" {
+				urlList = append(urlList, trimmed)
+			}
+		}
+
+		for _, url := range urlList {
+			magnet, err := utils.GetMagnetFromUrl(url)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("Failed to parse URL %s: %v", url, err))
+				continue
+			}
+			importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
+			if err := importReq.Process(ui.qbit); err != nil {
+				errs = append(errs, fmt.Sprintf("URL %s: %v", url, err))
+				continue
+			}
+			results = append(results, importReq)
+		}
+	}
+
+	// Handle torrent/magnet files
+	if files := r.MultipartForm.File["files"]; len(files) > 0 {
+		for _, fileHeader := range files {
+			file, err := fileHeader.Open()
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("Failed to open file %s: %v", fileHeader.Filename, err))
+				continue
+			}
+
+			magnet, err := utils.GetMagnetFromFile(file, fileHeader.Filename)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("Failed to parse torrent file %s: %v", fileHeader.Filename, err))
+				continue
+			}
+
+			importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
+			err = importReq.Process(ui.qbit)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("File %s: %v", fileHeader.Filename, err))
+				continue
+			}
+			results = append(results, importReq)
+		}
+	}
+
+	request.JSONResponse(w, struct {
+		Results []*qbit.ImportRequest `json:"results"`
+		Errors  []string              `json:"errors,omitempty"`
+	}{
+		Results: results,
+		Errors:  errs,
+	}, http.StatusOK)
+}
+
+func (ui *Handler) handleRepairMedia(w http.ResponseWriter, r *http.Request) {
+	var req RepairRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	svc := service.GetService()
+
+	var arrs []string
+
+	if req.ArrName != "" {
+		_arr := svc.Arr.Get(req.ArrName)
+		if _arr == nil {
+			http.Error(w, "No Arrs found to repair", http.StatusNotFound)
+			return
+		}
+		arrs = append(arrs, req.ArrName)
+	}
+
+	if req.Async {
+		go func() {
+			if err := svc.Repair.AddJob(arrs, req.MediaIds, req.AutoProcess, false); err != nil {
+				ui.logger.Error().Err(err).Msg("Failed to repair media")
+			}
+		}()
+		request.JSONResponse(w, "Repair process started", http.StatusOK)
+		return
+	}
+
+	if err := svc.Repair.AddJob([]string{req.ArrName}, req.MediaIds, req.AutoProcess, false); err != nil {
+		http.Error(w, fmt.Sprintf("Failed to repair: %v", err), http.StatusInternalServerError)
+		return
+	}
+
+	request.JSONResponse(w, "Repair completed", http.StatusOK)
+}
+
+func (ui *Handler) handleGetVersion(w http.ResponseWriter, r *http.Request) {
+	v := version.GetInfo()
+	request.JSONResponse(w, v, http.StatusOK)
+}
+
+func (ui *Handler) handleGetTorrents(w http.ResponseWriter, r *http.Request) {
+	request.JSONResponse(w, ui.qbit.Storage.GetAllSorted("", "", nil, "added_on", false), http.StatusOK)
+}
+
+func (ui *Handler) handleDeleteTorrent(w http.ResponseWriter, r *http.Request) {
+	hash := chi.URLParam(r, "hash")
+	category := chi.URLParam(r, "category")
+	removeFromDebrid := r.URL.Query().Get("removeFromDebrid") == "true"
+	if hash == "" {
+		http.Error(w, "No hash provided", http.StatusBadRequest)
+		return
+	}
+	ui.qbit.Storage.Delete(hash, category, removeFromDebrid)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (ui *Handler) handleDeleteTorrents(w http.ResponseWriter, r *http.Request) {
+	hashesStr := r.URL.Query().Get("hashes")
+	removeFromDebrid := r.URL.Query().Get("removeFromDebrid") == "true"
+	if hashesStr == "" {
+		http.Error(w, "No hashes provided", http.StatusBadRequest)
+		return
+	}
+	hashes := strings.Split(hashesStr, ",")
+	ui.qbit.Storage.DeleteMultiple(hashes, removeFromDebrid)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (ui *Handler) handleGetConfig(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	arrCfgs := make([]config.Arr, 0)
+	svc := service.GetService()
+	for _, a := range svc.Arr.GetAll() {
+		arrCfgs = append(arrCfgs, config.Arr{
+			Host:             a.Host,
+			Name:             a.Name,
+			Token:            a.Token,
+			Cleanup:          a.Cleanup,
+			SkipRepair:       a.SkipRepair,
+			DownloadUncached: a.DownloadUncached,
+		})
+	}
+	cfg.Arrs = arrCfgs
+	request.JSONResponse(w, cfg, http.StatusOK)
+}
+
+func (ui *Handler) handleUpdateConfig(w http.ResponseWriter, r *http.Request) {
+	// Decode the JSON body
+	var updatedConfig config.Config
+	if err := json.NewDecoder(r.Body).Decode(&updatedConfig); err != nil {
+		ui.logger.Error().Err(err).Msg("Failed to decode config update request")
+		http.Error(w, "Invalid request body: "+err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	// Get the current configuration
+	currentConfig := config.Get()
+
+	// Update fields that can be changed
+	currentConfig.LogLevel = updatedConfig.LogLevel
+	currentConfig.MinFileSize = updatedConfig.MinFileSize
+	currentConfig.MaxFileSize = updatedConfig.MaxFileSize
+	currentConfig.AllowedExt = updatedConfig.AllowedExt
+	currentConfig.DiscordWebhook = updatedConfig.DiscordWebhook
+
+	// Should this be added?
+	currentConfig.URLBase = updatedConfig.URLBase
+	currentConfig.BindAddress = updatedConfig.BindAddress
+	currentConfig.Port = updatedConfig.Port
+
+	// Update QBitTorrent config
+	currentConfig.QBitTorrent = updatedConfig.QBitTorrent
+
+	// Update Repair config
+	currentConfig.Repair = updatedConfig.Repair
+
+	// Update Debrids
+	if len(updatedConfig.Debrids) > 0 {
+		currentConfig.Debrids = updatedConfig.Debrids
+		// Clear legacy single debrid if using array
+	}
+
+	if len(updatedConfig.Arrs) > 0 {
+		currentConfig.Arrs = updatedConfig.Arrs
+	}
+
+	// Update Arrs through the service
+	svc := service.GetService()
+	svc.Arr.Clear() // Clear existing arrs
+
+	for _, a := range updatedConfig.Arrs {
+		svc.Arr.AddOrUpdate(&arr.Arr{
+			Name:             a.Name,
+			Host:             a.Host,
+			Token:            a.Token,
+			Cleanup:          a.Cleanup,
+			SkipRepair:       a.SkipRepair,
+			DownloadUncached: a.DownloadUncached,
+		})
+	}
+	currentConfig.Arrs = updatedConfig.Arrs
+	if err := currentConfig.Save(); err != nil {
+		http.Error(w, "Error saving config: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	if restartFunc != nil {
+		go func() {
+			// Small delay to ensure the response is sent
+			time.Sleep(500 * time.Millisecond)
+			restartFunc()
+		}()
+	}
+
+	// Return success
+	request.JSONResponse(w, map[string]string{"status": "success"}, http.StatusOK)
+}
+
+func (ui *Handler) handleGetRepairJobs(w http.ResponseWriter, r *http.Request) {
+	svc := service.GetService()
+	request.JSONResponse(w, svc.Repair.GetJobs(), http.StatusOK)
+}
+
+func (ui *Handler) handleProcessRepairJob(w http.ResponseWriter, r *http.Request) {
+	id := chi.URLParam(r, "id")
+	if id == "" {
+		http.Error(w, "No job ID provided", http.StatusBadRequest)
+		return
+	}
+	svc := service.GetService()
+	if err := svc.Repair.ProcessJob(id); err != nil {
+		ui.logger.Error().Err(err).Msg("Failed to process repair job")
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+func (ui *Handler) handleDeleteRepairJob(w http.ResponseWriter, r *http.Request) {
+	// Read ids from body
+	var req struct {
+		IDs []string `json:"ids"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	if len(req.IDs) == 0 {
+		http.Error(w, "No job IDs provided", http.StatusBadRequest)
+		return
+	}
+
+	svc := service.GetService()
+	svc.Repair.DeleteJobs(req.IDs)
+	w.WriteHeader(http.StatusOK)
+}

pkg/web/auth.go

@@ -0,0 +1,34 @@
+package web
+
+import (
+	"github.com/sirrobot01/decypharr/internal/config"
+	"golang.org/x/crypto/bcrypt"
+	"net/http"
+)
+
+func (ui *Handler) verifyAuth(username, password string) bool {
+	// If you're storing hashed password, use bcrypt to compare
+	if username == "" {
+		return false
+	}
+	auth := config.Get().GetAuth()
+	if auth == nil {
+		return false
+	}
+	if username != auth.Username {
+		return false
+	}
+	err := bcrypt.CompareHashAndPassword([]byte(auth.Password), []byte(password))
+	return err == nil
+}
+
+func (ui *Handler) skipAuthHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	cfg.UseAuth = false
+	if err := cfg.Save(); err != nil {
+		ui.logger.Error().Err(err).Msg("failed to save config")
+		http.Error(w, "failed to save config", http.StatusInternalServerError)
+		return
+	}
+	http.Redirect(w, r, "/", http.StatusSeeOther)
+}

pkg/web/middlewares.go

@@ -0,0 +1,51 @@
+package web
+
+import (
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/config"
+	"net/http"
+)
+
+func (ui *Handler) setupMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		cfg := config.Get()
+		needsAuth := cfg.NeedsSetup()
+		if needsAuth != nil && r.URL.Path != "/config" && r.URL.Path != "/api/config" {
+			http.Redirect(w, r, fmt.Sprintf("/config?inco=%s", needsAuth.Error()), http.StatusSeeOther)
+			return
+		}
+
+		// strip inco from URL
+		if inco := r.URL.Query().Get("inco"); inco != "" && needsAuth == nil && r.URL.Path == "/config" {
+			// redirect to the same URL without the inco parameter
+			http.Redirect(w, r, "/config", http.StatusSeeOther)
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (ui *Handler) authMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Check if setup is needed
+		cfg := config.Get()
+		if !cfg.UseAuth {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		if cfg.NeedsAuth() {
+			http.Redirect(w, r, "/register", http.StatusSeeOther)
+			return
+		}
+
+		session, _ := store.Get(r, "auth-session")
+		auth, ok := session.Values["authenticated"].(bool)
+
+		if !ok || !auth {
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}

pkg/web/routes.go

@@ -10,16 +10,19 @@ func (ui *Handler) Routes() http.Handler {
 
 	r.Get("/login", ui.LoginHandler)
 	r.Post("/login", ui.LoginHandler)
-	r.Get("/setup", ui.SetupHandler)
-	r.Post("/setup", ui.SetupHandler)
+	r.Get("/register", ui.RegisterHandler)
+	r.Post("/register", ui.RegisterHandler)
+	r.Get("/skip-auth", ui.skipAuthHandler)
+	r.Get("/version", ui.handleGetVersion)
 
 	r.Group(func(r chi.Router) {
 		r.Use(ui.authMiddleware)
+		r.Use(ui.setupMiddleware)
 		r.Get("/", ui.IndexHandler)
 		r.Get("/download", ui.DownloadHandler)
 		r.Get("/repair", ui.RepairHandler)
 		r.Get("/config", ui.ConfigHandler)
-		r.Route("/internal", func(r chi.Router) {
+		r.Route("/api", func(r chi.Router) {
 			r.Get("/arrs", ui.handleGetArrs)
 			r.Post("/add", ui.handleAddContent)
 			r.Post("/repair", ui.handleRepairMedia)
@@ -30,7 +33,7 @@ func (ui *Handler) Routes() http.Handler {
 			r.Delete("/torrents/{category}/{hash}", ui.handleDeleteTorrent)
 			r.Delete("/torrents/", ui.handleDeleteTorrents)
 			r.Get("/config", ui.handleGetConfig)
-			r.Get("/version", ui.handleGetVersion)
+			r.Post("/config", ui.handleUpdateConfig)
 		})
 	})
 

pkg/web/server.go

@@ -1,27 +1,23 @@
 package web
 
 import (
+	"cmp"
 	"embed"
-	"fmt"
-	"github.com/goccy/go-json"
 	"github.com/gorilla/sessions"
-	"github.com/sirrobot01/decypharr/internal/config"
-	"github.com/sirrobot01/decypharr/internal/logger"
-	"github.com/sirrobot01/decypharr/internal/request"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/qbit"
-	"github.com/sirrobot01/decypharr/pkg/service"
-	"golang.org/x/crypto/bcrypt"
-	"html/template"
-	"net/http"
-	"strings"
-
-	"github.com/go-chi/chi/v5"
 	"github.com/rs/zerolog"
-	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/version"
+	"github.com/sirrobot01/decypharr/internal/logger"
+	"github.com/sirrobot01/decypharr/pkg/qbit"
+	"html/template"
+	"os"
 )
 
+var restartFunc func()
+
+// SetRestartFunc allows setting a callback to restart services
+func SetRestartFunc(fn func()) {
+	restartFunc = fn
+}
+
 type AddRequest struct {
 	Url        string   `json:"url"`
 	Arr        string   `json:"arr"`
@@ -51,7 +47,7 @@ type RepairRequest struct {
 	AutoProcess bool     `json:"autoProcess"`
 }
 
-//go:embed web/*
+//go:embed templates/*
 var content embed.FS
 
 type Handler struct {
@@ -67,20 +63,21 @@ func New(qbit *qbit.QBit) *Handler {
 }
 
 var (
-	store     = sessions.NewCookieStore([]byte("your-secret-key")) // Change this to a secure key
+	secretKey = cmp.Or(os.Getenv("DECYPHARR_SECRET_KEY"), "\"wqj(v%lj*!-+kf@4&i95rhh_!5_px5qnuwqbr%cjrvrozz_r*(\"")
+	store     = sessions.NewCookieStore([]byte(secretKey))
 	templates *template.Template
 )
 
 func init() {
 	templates = template.Must(template.ParseFS(
 		content,
-		"web/layout.html",
-		"web/index.html",
-		"web/download.html",
-		"web/repair.html",
-		"web/config.html",
-		"web/login.html",
-		"web/setup.html",
+		"templates/layout.html",
+		"templates/index.html",
+		"templates/download.html",
+		"templates/repair.html",
+		"templates/config.html",
+		"templates/login.html",
+		"templates/register.html",
 	))
 
 	store.Options = &sessions.Options{
@@ -89,407 +86,3 @@ func init() {
 		HttpOnly: false,
 	}
 }
-
-func (ui *Handler) authMiddleware(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Check if setup is needed
-		cfg := config.Get()
-		if cfg.NeedsSetup() && r.URL.Path != "/setup" {
-			http.Redirect(w, r, "/setup", http.StatusSeeOther)
-			return
-		}
-
-		if !cfg.UseAuth {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		// Skip auth check for setup page
-		if r.URL.Path == "/setup" {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		session, _ := store.Get(r, "auth-session")
-		auth, ok := session.Values["authenticated"].(bool)
-
-		if !ok || !auth {
-			http.Redirect(w, r, "/login", http.StatusSeeOther)
-			return
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-func (ui *Handler) verifyAuth(username, password string) bool {
-	// If you're storing hashed password, use bcrypt to compare
-	if username == "" {
-		return false
-	}
-	auth := config.Get().GetAuth()
-	if auth == nil {
-		return false
-	}
-	if username != auth.Username {
-		return false
-	}
-	err := bcrypt.CompareHashAndPassword([]byte(auth.Password), []byte(password))
-	return err == nil
-}
-
-func (ui *Handler) LoginHandler(w http.ResponseWriter, r *http.Request) {
-	if r.Method == "GET" {
-		data := map[string]interface{}{
-			"Page":  "login",
-			"Title": "Login",
-		}
-		if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-		return
-	}
-
-	var credentials struct {
-		Username string `json:"username"`
-		Password string `json:"password"`
-	}
-
-	if err := json.NewDecoder(r.Body).Decode(&credentials); err != nil {
-		http.Error(w, "Invalid request", http.StatusBadRequest)
-		return
-	}
-
-	if ui.verifyAuth(credentials.Username, credentials.Password) {
-		session, _ := store.Get(r, "auth-session")
-		session.Values["authenticated"] = true
-		session.Values["username"] = credentials.Username
-		if err := session.Save(r, w); err != nil {
-			http.Error(w, "Error saving session", http.StatusInternalServerError)
-			return
-		}
-		http.Redirect(w, r, "/", http.StatusSeeOther)
-		return
-	}
-
-	http.Error(w, "Invalid credentials", http.StatusUnauthorized)
-}
-
-func (ui *Handler) LogoutHandler(w http.ResponseWriter, r *http.Request) {
-	session, _ := store.Get(r, "auth-session")
-	session.Values["authenticated"] = false
-	session.Options.MaxAge = -1
-	err := session.Save(r, w)
-	if err != nil {
-		return
-	}
-	http.Redirect(w, r, "/login", http.StatusSeeOther)
-}
-
-func (ui *Handler) SetupHandler(w http.ResponseWriter, r *http.Request) {
-	cfg := config.Get()
-	authCfg := cfg.GetAuth()
-
-	if !cfg.NeedsSetup() {
-		http.Redirect(w, r, "/", http.StatusSeeOther)
-		return
-	}
-
-	if r.Method == "GET" {
-		data := map[string]interface{}{
-			"Page":  "setup",
-			"Title": "Setup",
-		}
-		if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-		}
-		return
-	}
-
-	// Handle POST (setup attempt)
-	username := r.FormValue("username")
-	password := r.FormValue("password")
-	confirmPassword := r.FormValue("confirmPassword")
-
-	if password != confirmPassword {
-		http.Error(w, "Passwords do not match", http.StatusBadRequest)
-		return
-	}
-
-	// Hash the password
-	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
-	if err != nil {
-		http.Error(w, "Error processing password", http.StatusInternalServerError)
-		return
-	}
-
-	// Set the credentials
-	authCfg.Username = username
-	authCfg.Password = string(hashedPassword)
-
-	if err := cfg.SaveAuth(authCfg); err != nil {
-		http.Error(w, "Error saving credentials", http.StatusInternalServerError)
-		return
-	}
-
-	// Create a session
-	session, _ := store.Get(r, "auth-session")
-	session.Values["authenticated"] = true
-	session.Values["username"] = username
-	if err := session.Save(r, w); err != nil {
-		http.Error(w, "Error saving session", http.StatusInternalServerError)
-		return
-	}
-
-	http.Redirect(w, r, "/", http.StatusSeeOther)
-}
-
-func (ui *Handler) IndexHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "index",
-		"Title": "Torrents",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (ui *Handler) DownloadHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "download",
-		"Title": "Download",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (ui *Handler) RepairHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "repair",
-		"Title": "Repair",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (ui *Handler) ConfigHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "config",
-		"Title": "Config",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (ui *Handler) handleGetArrs(w http.ResponseWriter, r *http.Request) {
-	svc := service.GetService()
-	request.JSONResponse(w, svc.Arr.GetAll(), http.StatusOK)
-}
-
-func (ui *Handler) handleAddContent(w http.ResponseWriter, r *http.Request) {
-	if err := r.ParseMultipartForm(32 << 20); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	svc := service.GetService()
-
-	results := make([]*qbit.ImportRequest, 0)
-	errs := make([]string, 0)
-
-	arrName := r.FormValue("arr")
-	notSymlink := r.FormValue("notSymlink") == "true"
-	downloadUncached := r.FormValue("downloadUncached") == "true"
-
-	_arr := svc.Arr.Get(arrName)
-	if _arr == nil {
-		_arr = arr.New(arrName, "", "", false, false, &downloadUncached)
-	}
-
-	// Handle URLs
-	if urls := r.FormValue("urls"); urls != "" {
-		var urlList []string
-		for _, u := range strings.Split(urls, "\n") {
-			if trimmed := strings.TrimSpace(u); trimmed != "" {
-				urlList = append(urlList, trimmed)
-			}
-		}
-
-		for _, url := range urlList {
-			magnet, err := utils.GetMagnetFromUrl(url)
-			if err != nil {
-				errs = append(errs, fmt.Sprintf("Failed to parse URL %s: %v", url, err))
-				continue
-			}
-			importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
-			if err := importReq.Process(ui.qbit); err != nil {
-				errs = append(errs, fmt.Sprintf("URL %s: %v", url, err))
-				continue
-			}
-			results = append(results, importReq)
-		}
-	}
-
-	// Handle torrent/magnet files
-	if files := r.MultipartForm.File["files"]; len(files) > 0 {
-		for _, fileHeader := range files {
-			file, err := fileHeader.Open()
-			if err != nil {
-				errs = append(errs, fmt.Sprintf("Failed to open file %s: %v", fileHeader.Filename, err))
-				continue
-			}
-
-			magnet, err := utils.GetMagnetFromFile(file, fileHeader.Filename)
-			if err != nil {
-				errs = append(errs, fmt.Sprintf("Failed to parse torrent file %s: %v", fileHeader.Filename, err))
-				continue
-			}
-
-			importReq := qbit.NewImportRequest(magnet, _arr, !notSymlink, downloadUncached)
-			err = importReq.Process(ui.qbit)
-			if err != nil {
-				errs = append(errs, fmt.Sprintf("File %s: %v", fileHeader.Filename, err))
-				continue
-			}
-			results = append(results, importReq)
-		}
-	}
-
-	request.JSONResponse(w, struct {
-		Results []*qbit.ImportRequest `json:"results"`
-		Errors  []string              `json:"errors,omitempty"`
-	}{
-		Results: results,
-		Errors:  errs,
-	}, http.StatusOK)
-}
-
-func (ui *Handler) handleRepairMedia(w http.ResponseWriter, r *http.Request) {
-	var req RepairRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	svc := service.GetService()
-
-	var arrs []string
-
-	if req.ArrName != "" {
-		_arr := svc.Arr.Get(req.ArrName)
-		if _arr == nil {
-			http.Error(w, "No Arrs found to repair", http.StatusNotFound)
-			return
-		}
-		arrs = append(arrs, req.ArrName)
-	}
-
-	if req.Async {
-		go func() {
-			if err := svc.Repair.AddJob(arrs, req.MediaIds, req.AutoProcess, false); err != nil {
-				ui.logger.Error().Err(err).Msg("Failed to repair media")
-			}
-		}()
-		request.JSONResponse(w, "Repair process started", http.StatusOK)
-		return
-	}
-
-	if err := svc.Repair.AddJob([]string{req.ArrName}, req.MediaIds, req.AutoProcess, false); err != nil {
-		http.Error(w, fmt.Sprintf("Failed to repair: %v", err), http.StatusInternalServerError)
-		return
-	}
-
-	request.JSONResponse(w, "Repair completed", http.StatusOK)
-}
-
-func (ui *Handler) handleGetVersion(w http.ResponseWriter, r *http.Request) {
-	v := version.GetInfo()
-	request.JSONResponse(w, v, http.StatusOK)
-}
-
-func (ui *Handler) handleGetTorrents(w http.ResponseWriter, r *http.Request) {
-	request.JSONResponse(w, ui.qbit.Storage.GetAll("", "", nil), http.StatusOK)
-}
-
-func (ui *Handler) handleDeleteTorrent(w http.ResponseWriter, r *http.Request) {
-	hash := chi.URLParam(r, "hash")
-	category := r.URL.Query().Get("category")
-	if hash == "" {
-		http.Error(w, "No hash provided", http.StatusBadRequest)
-		return
-	}
-	ui.qbit.Storage.Delete(hash, category)
-	w.WriteHeader(http.StatusOK)
-}
-
-func (ui *Handler) handleDeleteTorrents(w http.ResponseWriter, r *http.Request) {
-	hashesStr := r.URL.Query().Get("hashes")
-	if hashesStr == "" {
-		http.Error(w, "No hashes provided", http.StatusBadRequest)
-		return
-	}
-	hashes := strings.Split(hashesStr, ",")
-	ui.qbit.Storage.DeleteMultiple(hashes)
-	w.WriteHeader(http.StatusOK)
-}
-
-func (ui *Handler) handleGetConfig(w http.ResponseWriter, r *http.Request) {
-	cfg := config.Get()
-	arrCfgs := make([]config.Arr, 0)
-	svc := service.GetService()
-	for _, a := range svc.Arr.GetAll() {
-		arrCfgs = append(arrCfgs, config.Arr{
-			Host:             a.Host,
-			Name:             a.Name,
-			Token:            a.Token,
-			Cleanup:          a.Cleanup,
-			SkipRepair:       a.SkipRepair,
-			DownloadUncached: a.DownloadUncached,
-		})
-	}
-	cfg.Arrs = arrCfgs
-	request.JSONResponse(w, cfg, http.StatusOK)
-}
-
-func (ui *Handler) handleGetRepairJobs(w http.ResponseWriter, r *http.Request) {
-	svc := service.GetService()
-	request.JSONResponse(w, svc.Repair.GetJobs(), http.StatusOK)
-}
-
-func (ui *Handler) handleProcessRepairJob(w http.ResponseWriter, r *http.Request) {
-	id := chi.URLParam(r, "id")
-	if id == "" {
-		http.Error(w, "No job ID provided", http.StatusBadRequest)
-		return
-	}
-	svc := service.GetService()
-	if err := svc.Repair.ProcessJob(id); err != nil {
-		ui.logger.Error().Err(err).Msg("Failed to process repair job")
-	}
-	w.WriteHeader(http.StatusOK)
-}
-
-func (ui *Handler) handleDeleteRepairJob(w http.ResponseWriter, r *http.Request) {
-	// Read ids from body
-	var req struct {
-		IDs []string `json:"ids"`
-	}
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	if len(req.IDs) == 0 {
-		http.Error(w, "No job IDs provided", http.StatusBadRequest)
-		return
-	}
-
-	svc := service.GetService()
-	svc.Repair.DeleteJobs(req.IDs)
-	w.WriteHeader(http.StatusOK)
-}

pkg/web/templates/download.html

@@ -112,7 +112,7 @@
                     formData.append('notSymlink', document.getElementById('isSymlink').checked);
                     formData.append('downloadUncached', document.getElementById('downloadUncached').checked);
 
-                    const response = await fetch('/internal/add', {
+                    const response = await fetcher('/api/add', {
                         method: 'POST',
                         body: formData
                     });
@@ -127,8 +127,8 @@
                         }
                     } else {
                         createToast(`Successfully added ${result.results.length} torrents!`);
-                        //document.getElementById('magnetURI').value = '';
-                        //document.getElementById('torrentFiles').value = '';
+                        document.getElementById('magnetURI').value = '';
+                        document.getElementById('torrentFiles').value = '';
                     }
                 } catch (error) {
                     createToast(`Error adding downloads: ${error.message}`, 'error');

pkg/web/templates/index.html

@@ -12,7 +12,7 @@
                     </button>
                     <select class="form-select form-select-sm d-inline-block w-auto me-2" id="stateFilter" style="flex-shrink: 0;">
                         <option value="">All States</option>
-                        <option value="pausedup">Completed</option>
+                        <option value="pausedUP">PausedUP(Completed)</option>
                         <option value="downloading">Downloading</option>
                         <option value="error">Error</option>
                     </select>
@@ -80,7 +80,7 @@
             torrents: [],
             selectedTorrents: new Set(),
             categories: new Set(),
-            states: new Set('downloading', 'pausedup', 'error'),
+            states: new Set('downloading', 'pausedUP', 'error'),
             selectedCategory: refs.categoryFilter?.value || '',
             selectedState: refs.stateFilter?.value || '',
             sortBy: refs.sortSelector?.value || 'added_on',
@@ -110,9 +110,14 @@
             <td>${torrent.debrid || 'None'}</td>
             <td><span class="badge ${getStateColor(torrent.state)}">${torrent.state}</span></td>
             <td>
-                <button class="btn btn-sm btn-outline-danger" onclick="deleteTorrent('${torrent.hash}', '${torrent.category}')">
+                <button class="btn btn-sm btn-outline-danger" onclick="deleteTorrent('${torrent.hash}', '${torrent.category}', false)">
                     <i class="bi bi-trash"></i>
                 </button>
+                ${torrent.debrid && torrent.id  ? `
+                    <button class="btn btn-sm btn-outline-danger" onclick="deleteTorrent('${torrent.hash}', '${torrent.category}', true)">
+                    <i class="bi bi-trash"></i> Remove from Debrid
+                </button>
+                ` : ''}
             </td>
         </tr>
         `;
@@ -185,7 +190,7 @@
 
         async function loadTorrents() {
             try {
-                const response = await fetch('/internal/torrents');
+                const response = await fetcher('/api/torrents');
                 const torrents = await response.json();
                 
                 state.torrents = torrents;
@@ -247,11 +252,11 @@
             return result;
         }
 
-        async function deleteTorrent(hash, category) {
+        async function deleteTorrent(hash, category, removeFromDebrid = false) {
             if (!confirm('Are you sure you want to delete this torrent?')) return;
 
             try {
-                await fetch(`/internal/torrents/${category}/${hash}`, {
+                await fetcher(`/api/torrents/${category}/${hash}?removeFromDebrid=${removeFromDebrid}`, {
                     method: 'DELETE'
                 });
                 await loadTorrents();
@@ -268,7 +273,7 @@
             try {
                 // COmma separated list of hashes
                 const hashes = Array.from(state.selectedTorrents).join(',');
-                await fetch(`/internal/torrents/?hashes=${encodeURIComponent(hashes)}`, {
+                await fetcher(`/api/torrents/?hashes=${encodeURIComponent(hashes)}`, {
                     method: 'DELETE'
                 });
                 await loadTorrents();

pkg/web/templates/layout.html

@@ -4,7 +4,7 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>DecyphArr - {{.Title}}</title>
+    <title>Decypharr - {{.Title}}</title>
     <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.2/font/bootstrap-icons.css" rel="stylesheet">
     <link href="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/css/select2.min.css" rel="stylesheet"/>
@@ -68,17 +68,6 @@
             font-weight: 500;
         }
 
-        .badge#channel-badge {
-            background-color: #0d6efd;
-        }
-
-        .badge#channel-badge.beta {
-            background-color: #fd7e14;
-        }
-        .badge#channel-badge.nightly {
-            background-color: #6c757d;
-        }
-
         .table {
             color: var(--text-color);
         }
@@ -137,7 +126,7 @@
 <nav class="navbar navbar-expand-lg navbar-light mb-4">
     <div class="container">
         <a class="navbar-brand" href="/">
-            <i class="bi bi-cloud-download me-2"></i>DecyphArr
+            <i class="bi bi-cloud-download me-2"></i>Decypharr
         </a>
         <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarNav">
             <span class="navbar-toggler-icon"></span>
@@ -145,32 +134,32 @@
         <div class="collapse navbar-collapse" id="navbarNav">
             <ul class="navbar-nav me-auto">
                 <li class="nav-item">
-                    <a class="nav-link {{if eq .Page "index"}}active{{end}}" href="/">
+                    <a class="nav-link {{if eq .Page "index"}}active{{end}}" href="{{.URLBase}}">
                     <i class="bi bi-table me-1"></i>Torrents
                     </a>
                 </li>
                 <li class="nav-item">
-                    <a class="nav-link {{if eq .Page "download"}}active{{end}}" href="/download">
+                    <a class="nav-link {{if eq .Page "download"}}active{{end}}" href="{{.URLBase}}download">
                     <i class="bi bi-cloud-download me-1"></i>Download
                     </a>
                 </li>
                 <li class="nav-item">
-                    <a class="nav-link {{if eq .Page "repair"}}active{{end}}" href="/repair">
+                    <a class="nav-link {{if eq .Page "repair"}}active{{end}}" href="{{.URLBase}}repair">
                     <i class="bi bi-tools me-1"></i>Repair
                     </a>
                 </li>
                 <li class="nav-item">
-                    <a class="nav-link {{if eq .Page "config"}}active{{end}}" href="/config">
+                    <a class="nav-link {{if eq .Page "config"}}active{{end}}" href="{{.URLBase}}config">
                     <i class="bi bi-gear me-1"></i>Settings
                     </a>
                 </li>
                 <li class="nav-item">
-                    <a class="nav-link" href="/webdav" target="_blank">
+                    <a class="nav-link" href="{{.URLBase}}webdav" target="_blank">
                         <i class="bi bi-cloud me-1"></i>WebDAV
                     </a>
                 </li>
                 <li class="nav-item">
-                    <a class="nav-link" href="/logs" target="_blank">
+                    <a class="nav-link" href="{{.URLBase}}logs" target="_blank">
                         <i class="bi bi-journal me-1"></i>Logs
                     </a>
                 </li>
@@ -180,7 +169,9 @@
                     <i class="bi bi-sun-fill" id="lightIcon"></i>
                     <i class="bi bi-moon-fill d-none" id="darkIcon"></i>
                 </div>
-                <span class="badge me-2" id="channel-badge">Loading...</span>
+                <a href="{{.URLBase}}stats" class="me-2">
+                    <i class="bi bi-bar-chart-line me-1"></i>Stats
+                </a>
                 <span class="badge bg-primary" id="version-badge">Loading...</span>
             </div>
         </div>
@@ -197,8 +188,8 @@
 {{ template "config" . }}
 {{ else if eq .Page "login" }}
 {{ template "login" . }}
-{{ else if eq .Page "setup" }}
-{{ template "setup" . }}
+{{ else if eq .Page "register" }}
+{{ template "register" . }}
 {{ else }}
 {{ end }}
 
@@ -206,6 +197,29 @@
 <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/js/select2.min.js"></script>
 <script>
+
+    window.urlBase = "{{.URLBase}}";
+
+    function joinURL(base, path) {
+        if (!base.endsWith('/')) {
+            base += '/';
+        }
+        if (path.startsWith('/')) {
+            path = path.substring(1);
+        }
+        return base + path;
+
+    }
+
+    function fetcher(endpoint, options = {}) {
+        // Use the global urlBase or default to empty string
+        let baseUrl = window.urlBase || '';
+
+        let url = joinURL(baseUrl, endpoint);
+
+        // Return the regular fetcher with the complete URL
+        return fetch(url, options);
+    }
     /**
      * Create a toast message
      * @param {string} message - The message to display
@@ -243,6 +257,7 @@
         const toast = new bootstrap.Toast(toastElement, {
             autohide: true,
             delay: toastTimeouts[type]
+
         });
 
         toast.show();
@@ -302,26 +317,24 @@
     }
 
     document.addEventListener('DOMContentLoaded', function() {
-        fetch('/internal/version')
+        fetcher('/version')
             .then(response => response.json())
             .then(data => {
                 const versionBadge = document.getElementById('version-badge');
-                const channelBadge = document.getElementById('channel-badge');
 
                 // Add url to version badge
-                versionBadge.innerHTML = `<a href="https://github.com/sirrobot01/decypharr/releases/tag/${data.version}" target="_blank" class="text-white">${data.version}</a>`;
-                channelBadge.textContent = data.channel.charAt(0).toUpperCase() + data.channel.slice(1);
+                versionBadge.innerHTML = `<a href="https://github.com/sirrobot01/decypharr/releases/tag/${data.version}" target="_blank" class="text-white">${data.channel}-${data.version}</a>`;
+
 
                 if (data.channel === 'beta') {
-                    channelBadge.classList.add('beta');
+                    versionBadge.classList.add('beta');
                 } else if (data.channel === 'nightly') {
-                    channelBadge.classList.add('nightly');
+                    versionBadge.classList.add('nightly');
                 }
             })
             .catch(error => {
                 console.error('Error fetching version:', error);
                 document.getElementById('version-badge').textContent = 'Unknown';
-                document.getElementById('channel-badge').textContent = 'Unknown';
             });
     });
 </script>

pkg/web/templates/login.html

@@ -0,0 +1,58 @@
+{{ define "login" }}
+<div class="container mt-5">
+    <div class="row justify-content-center">
+        <div class="col-md-6 col-lg-4">
+            <div class="card">
+                <div class="card-header">
+                    <h4 class="mb-0 text-center">Login</h4>
+                </div>
+                <div class="card-body">
+                    <form id="loginForm">
+                        <div class="mb-3">
+                            <label for="username" class="form-label">Username</label>
+                            <input type="text" class="form-control" id="username" name="username" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="password" class="form-label">Password</label>
+                            <input type="password" class="form-control" id="password" name="password" required>
+                        </div>
+                        <div class="d-grid">
+                            <button type="submit" class="btn btn-primary">Login</button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    document.getElementById('loginForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+
+        const formData = {
+            username: document.getElementById('username').value,
+            password: document.getElementById('password').value
+        };
+
+        try {
+            const response = await fetcher('/login', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(formData)
+            });
+
+            if (response.ok) {
+                window.location.href = '/';
+            } else {
+                createToast('Invalid credentials', 'error');
+            }
+        } catch (error) {
+            console.error('Login error:', error);
+            createToast('Login failed', 'error');
+        }
+    });
+</script>
+{{ end }}

pkg/web/templates/register.html

@@ -0,0 +1,92 @@
+{{ define "register" }}
+<div class="container mt-5">
+    <div class="row justify-content-center">
+        <div class="col-md-6 col-lg-4">
+            <div class="card">
+                <div class="card-header">
+                    <h4 class="mb-0 text-center">First Time Auth Setup</h4>
+                </div>
+                <div class="card-body">
+                    <form id="authForm">
+                        <div class="mb-3">
+                            <label for="username" class="form-label">Username</label>
+                            <input type="text" class="form-control" id="username" name="username" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="password" class="form-label">Password</label>
+                            <input type="password" class="form-control" id="password" name="password" required>
+                        </div>
+                        <div class="mb-3">
+                            <label for="confirmPassword" class="form-label">Confirm Password</label>
+                            <input type="password" class="form-control" id="confirmPassword" name="confirmPassword" required>
+                        </div>
+                        <div class="d-grid gap-2">
+                            <button type="submit" class="btn btn-primary mb-2">Save</button>
+                            <button type="button" id="skipAuthBtn" class="btn btn-secondary">Skip</button>
+                        </div>
+                    </form>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+    document.addEventListener('DOMContentLoaded', function() {
+        const authForm = document.getElementById('authForm');
+        const skipAuthBtn = document.getElementById('skipAuthBtn');
+
+        authForm.addEventListener('submit', async function (e) {
+            e.preventDefault();
+
+            // Validate passwords match
+            const password = document.getElementById('password').value;
+            const confirmPassword = document.getElementById('confirmPassword').value;
+
+            if (password !== confirmPassword) {
+                alert('Passwords do not match!');
+                return;
+            }
+
+            // Collect form data
+            let formData = new FormData();
+            formData.append('username', document.getElementById('username').value);
+            formData.append('password', password);
+            formData.append('confirmPassword', confirmPassword);
+            await fetcher('/register', {
+                method: 'POST',
+                body: formData
+            })
+                .then(response => {
+                    if (!response.ok) {
+                        return response.text().then(errorText => {
+                            // Throw an error with the response text
+                            createToast(errorText || 'Registration failed', 'error');
+                        });
+                    } else {
+                        window.location.href = joinURL(window.urlBase, '/');
+                    }
+
+                })
+                .catch(error => {
+                    alert('Registration failed: ' + error.message);
+                });
+        });
+
+        // Handle skip auth button
+        skipAuthBtn.addEventListener('click', function() {
+            fetcher('/skip-auth', { method: 'GET' })
+                .then(response => {
+                    if (response.ok) {
+                        window.location.href = joinURL(window.urlBase, '/');
+                    } else {
+                        throw new Error('Failed to skip authentication');
+                    }
+                })
+                .catch(error => {
+                    alert('Error: ' + error.message);
+                });
+        });
+    });
+</script>
+{{ end }}

pkg/web/templates/repair.html

@@ -152,7 +152,7 @@
 <script>
     document.addEventListener('DOMContentLoaded', () => {
         // Load Arr instances
-        fetch('/internal/arrs')
+        fetcher('/api/arrs')
             .then(response => response.json())
             .then(arrs => {
                 const select = document.getElementById('arrSelect');
@@ -175,7 +175,7 @@
             let mediaIds = document.getElementById('mediaIds').value.split(',').map(id => id.trim());
             let arr = document.getElementById('arrSelect').value;
             try {
-                const response = await fetch('/internal/repair', {
+                const response = await fetcher('/api/repair', {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json'
@@ -207,8 +207,8 @@
         // Load jobs function
         async function loadJobs(page) {
             try {
-                const response = await fetch('/internal/repair/jobs');
-                if (!response.ok) throw new Error('Failed to fetch jobs');
+                const response = await fetcher('/api/repair/jobs');
+                if (!response.ok) throw new Error('Failed to fetcher jobs');
 
                 allJobs = await response.json();
                 renderJobsTable(page);
@@ -403,7 +403,7 @@
         async function deleteJob(jobId) {
             if (confirm('Are you sure you want to delete this job?')) {
                 try {
-                    const response = await fetch(`/internal/repair/jobs`, {
+                    const response = await fetcher(`/api/repair/jobs`, {
                         method: 'DELETE',
                         headers: {
                             'Content-Type': 'application/json'
@@ -422,7 +422,7 @@
 
         async function deleteMultipleJobs(jobIds) {
             try {
-                const response = await fetch(`/internal/repair/jobs`, {
+                const response = await fetcher(`/api/repair/jobs`, {
                     method: 'DELETE',
                     headers: {
                         'Content-Type': 'application/json'
@@ -441,7 +441,7 @@
         // Process job function
         async function processJob(jobId) {
             try {
-                const response = await fetch(`/internal/repair/jobs/${jobId}/process`, {
+                const response = await fetcher(`/api/repair/jobs/${jobId}/process`, {
                     method: 'POST',
                     headers: {
                         'Content-Type': 'application/json'

pkg/web/ui.go

@@ -0,0 +1,151 @@
+package web
+
+import (
+	"encoding/json"
+	"github.com/sirrobot01/decypharr/internal/config"
+	"golang.org/x/crypto/bcrypt"
+	"net/http"
+)
+
+func (ui *Handler) LoginHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	if cfg.NeedsAuth() {
+		http.Redirect(w, r, "/register", http.StatusSeeOther)
+		return
+	}
+	if r.Method == "GET" {
+		data := map[string]interface{}{
+			"URLBase": cfg.URLBase,
+			"Page":    "login",
+			"Title":   "Login",
+		}
+		_ = templates.ExecuteTemplate(w, "layout", data)
+		return
+	}
+
+	var credentials struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+
+	if err := json.NewDecoder(r.Body).Decode(&credentials); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	if ui.verifyAuth(credentials.Username, credentials.Password) {
+		session, _ := store.Get(r, "auth-session")
+		session.Values["authenticated"] = true
+		session.Values["username"] = credentials.Username
+		if err := session.Save(r, w); err != nil {
+			http.Error(w, "Error saving session", http.StatusInternalServerError)
+			return
+		}
+		http.Redirect(w, r, "/", http.StatusSeeOther)
+		return
+	}
+
+	http.Error(w, "Invalid credentials", http.StatusUnauthorized)
+}
+
+func (ui *Handler) LogoutHandler(w http.ResponseWriter, r *http.Request) {
+	session, _ := store.Get(r, "auth-session")
+	session.Values["authenticated"] = false
+	session.Options.MaxAge = -1
+	err := session.Save(r, w)
+	if err != nil {
+		return
+	}
+	http.Redirect(w, r, "/login", http.StatusSeeOther)
+}
+
+func (ui *Handler) RegisterHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	authCfg := cfg.GetAuth()
+
+	if r.Method == "GET" {
+		data := map[string]interface{}{
+			"URLBase": cfg.URLBase,
+			"Page":    "register",
+			"Title":   "Register",
+		}
+		_ = templates.ExecuteTemplate(w, "layout", data)
+		return
+	}
+
+	username := r.FormValue("username")
+	password := r.FormValue("password")
+	confirmPassword := r.FormValue("confirmPassword")
+
+	if password != confirmPassword {
+		http.Error(w, "Passwords do not match", http.StatusBadRequest)
+		return
+	}
+
+	// Hash the password
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		http.Error(w, "Error processing password", http.StatusInternalServerError)
+		return
+	}
+
+	// Set the credentials
+	authCfg.Username = username
+	authCfg.Password = string(hashedPassword)
+
+	if err := cfg.SaveAuth(authCfg); err != nil {
+		http.Error(w, "Error saving credentials", http.StatusInternalServerError)
+		return
+	}
+
+	// Create a session
+	session, _ := store.Get(r, "auth-session")
+	session.Values["authenticated"] = true
+	session.Values["username"] = username
+	if err := session.Save(r, w); err != nil {
+		http.Error(w, "Error saving session", http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, "/", http.StatusSeeOther)
+}
+
+func (ui *Handler) IndexHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	data := map[string]interface{}{
+		"URLBase": cfg.URLBase,
+		"Page":    "index",
+		"Title":   "Torrents",
+	}
+	_ = templates.ExecuteTemplate(w, "layout", data)
+}
+
+func (ui *Handler) DownloadHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	data := map[string]interface{}{
+		"URLBase": cfg.URLBase,
+		"Page":    "download",
+		"Title":   "Download",
+	}
+	_ = templates.ExecuteTemplate(w, "layout", data)
+}
+
+func (ui *Handler) RepairHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	data := map[string]interface{}{
+		"URLBase": cfg.URLBase,
+		"Page":    "repair",
+		"Title":   "Repair",
+	}
+	_ = templates.ExecuteTemplate(w, "layout", data)
+}
+
+func (ui *Handler) ConfigHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.Get()
+	data := map[string]interface{}{
+		"URLBase": cfg.URLBase,
+		"Page":    "config",
+		"Title":   "Config",
+	}
+	_ = templates.ExecuteTemplate(w, "layout", data)
+}

pkg/web/web/config.html

@@ -1,495 +0,0 @@
-{{ define "config" }}
-    <div class="container mt-4">
-        <div class="card">
-            <div class="card-header">
-                <h4 class="mb-0"><i class="bi bi-gear me-2"></i>Configuration</h4>
-            </div>
-            <div class="card-body">
-                <form id="configForm">
-                    <div class="section mb-5">
-                        <h5 class="border-bottom pb-2">General Configuration</h5>
-                        <div class="row">
-                            <div class="col-md-6">
-                            <div class="form-group">
-                                <label for="log-level">Log Level</label>
-                                <select class="form-select" name="log_level" id="log-level" disabled>
-                                    <option value="info">Info</option>
-                                    <option value="debug">Debug</option>
-                                    <option value="warn">Warning</option>
-                                    <option value="error">Error</option>
-                                    <option value="trace">Trace</option>
-                                </select>
-                            </div>
-                            </div>
-                            <!-- Register Magnet Link Button -->
-                             <div class="col-md-6">
-                                <label>
-                                    <!-- Empty label to keep the button aligned -->
-                                </label>
-                                <div class="btn btn-primary w-100" onclick="registerMagnetLinkHandler()" id="registerMagnetLink">
-                                    Open Magnet Links in Decypharr
-                                </div>
-                            </div>
-                            <div class="col-md-6 mt-3">
-                                <div class="form-group">
-                                    <label for="discordWebhookUrl">Discord Webhook URL</label>
-                                    <div class="input-group">
-                                        <textarea type="text"
-                                               class="form-control"
-                                               id="discordWebhookUrl"
-                                               name="discord_webhook_url"
-                                               disabled
-                                               placeholder="https://discord..."></textarea>
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="col-md-6 mt-3">
-                                <div class="form-group">
-                                    <label for="allowedExtensions">Allowed File Extensions</label>
-                                    <div class="input-group">
-                                        <textarea
-                                               class="form-control"
-                                               id="allowedExtensions"
-                                               name="allowed_file_types"
-                                               disabled
-                                               placeholder="mkv, mp4, avi, etc.">
-                                        </textarea>
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="col-md-6 mt-3">
-                                <div class="form-group">
-                                    <label for="minFileSize">Minimum File Size</label>
-                                    <input type="text"
-                                           class="form-control"
-                                           id="minFileSize"
-                                           name="min_file_size"
-                                           disabled
-                                           placeholder="e.g., 10MB, 1GB">
-                                    <small class="form-text text-muted">Minimum file size to download (0 for no limit)</small>
-                                </div>
-                            </div>
-
-                            <div class="col-md-6 mt-3">
-                                <div class="form-group">
-                                    <label for="maxFileSize">Maximum File Size</label>
-                                    <input type="text"
-                                           class="form-control"
-                                           id="maxFileSize"
-                                           name="max_file_size"
-                                           disabled
-                                           placeholder="e.g., 50GB, 100MB">
-                                    <small class="form-text text-muted">Maximum file size to download (0 for no limit)</small>
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                    <!-- Debrid Configuration -->
-                    <div class="section mb-5">
-                        <h5 class="border-bottom pb-2">Debrids</h5>
-                        <div id="debridConfigs"></div>
-                    </div>
-
-                    <!-- QBitTorrent Configuration -->
-                    <div class="section mb-5">
-                        <h5 class="border-bottom pb-2">QBitTorrent</h5>
-                        <div class="row">
-                            <div class="col-md-6 mb-3">
-                                <label class="form-label">Username</label>
-                                <input type="text" disabled class="form-control" name="qbit.username">
-                            </div>
-                            <div class="col-md-6 mb-3">
-                                <label class="form-label">Password</label>
-                                <input type="password" disabled class="form-control" name="qbit.password">
-                            </div>
-                            <div class="col-md-6 mb-3">
-                                <label class="form-label">Port</label>
-                                <input type="text" disabled class="form-control" name="qbit.port">
-                            </div>
-                            <div class="col-md-6 mb-3">
-                                <label class="form-label">Symlink/Download Folder</label>
-                                <input type="text" disabled class="form-control" name="qbit.download_folder">
-                            </div>
-                            <div class="col-md-6 mb-3">
-                                <label class="form-label">Refresh Interval (seconds)</label>
-                                <input type="number" class="form-control" name="qbit.refresh_interval">
-                            </div>
-                            <div class="col-md-6 mb-3">
-                                <input type="checkbox" disabled class="form-check-input" name="qbit.skip_pre_cache">
-                                <label class="form-check-label">Skip Pre-Cache On Download(This caches a tiny part of your file to speed up import)</label>
-                            </div>
-                        </div>
-                    </div>
-
-                    <!-- Arr Configurations -->
-                    <div class="section mb-5">
-                        <h5 class="border-bottom pb-2">Arrs</h5>
-                        <div id="arrConfigs"></div>
-                    </div>
-
-                    <!-- Repair Configuration -->
-                    <div class="section mb-5">
-                        <h5 class="border-bottom pb-2">Repair Configuration</h5>
-                        <div class="row">
-                            <div class="col-md-3 mb-3">
-                                <label class="form-label">Interval</label>
-                                <input type="text" disabled class="form-control" name="repair.interval" placeholder="e.g., 24h">
-                            </div>
-                            <div class="col-md-4 mb-3">
-                                <label class="form-label">Zurg URL</label>
-                                <input type="text" disabled class="form-control" name="repair.zurg_url" placeholder="http://zurg:9999">
-                            </div>
-                        </div>
-                        <div class="col-12">
-                            <div class="form-check me-3 d-inline-block">
-                                <input type="checkbox" disabled class="form-check-input" name="repair.enabled" id="repairEnabled">
-                                <label class="form-check-label" for="repairEnabled">Enable Repair</label>
-                            </div>
-                            <div class="form-check me-3 d-inline-block">
-                                <input type="checkbox" disabled class="form-check-input" name="repair.use_webdav" id="repairUseWebdav">
-                                <label class="form-check-label" for="repairUseWebdav">Use Webdav</label>
-                            </div>
-                            <div class="form-check me-3 d-inline-block">
-                                <input type="checkbox" disabled class="form-check-input" name="repair.run_on_start" id="repairOnStart">
-                                <label class="form-check-label" for="repairOnStart">Run on Start</label>
-                            </div>
-                            <div class="form-check d-inline-block">
-                                <input type="checkbox" disabled class="form-check-input" name="repair.auto_process" id="autoProcess">
-                                <label class="form-check-label" for="autoProcess">Auto Process(Scheduled jobs will be processed automatically)</label>
-                            </div>
-                        </div>
-                    </div>
-                </form>
-            </div>
-        </div>
-    </div>
-    <script>
-        // Templates for dynamic elements
-        const debridTemplate = (index) => `
-        <div class="config-item position-relative mb-3 p-3 border rounded">
-            <div class="row mb-2">
-                <div class="col-md-6 mb-3">
-                    <label class="form-label">Name</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].name" required>
-                </div>
-                <div class="col-md-6 mb-3">
-                    <label class="form-label">Host</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].host" required>
-                </div>
-                <div class="col-md-6 mb-3">
-                    <label class="form-label">API Key</label>
-                    <input type="password" disabled class="form-control" name="debrid[${index}].api_key" required>
-                </div>
-                <div class="col-md-6 mb-3">
-                    <label class="form-label">Mount Folder</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].folder">
-                </div>
-                <div class="col-md-6 mb-3">
-                    <label class="form-label">Rate Limit</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].rate_limit" placeholder="e.g., 200/minute">
-                </div>
-                <div class="col-12">
-                    <div class="form-check me-3 d-inline-block">
-                        <input type="checkbox" disabled class="form-check-input" name="debrid[${index}].download_uncached">
-                        <label class="form-check-label">Download Uncached</label>
-                    </div>
-                    <div class="form-check d-inline-block">
-                        <input type="checkbox" disabled class="form-check-input" name="debrid[${index}].check_cached">
-                        <label class="form-check-label">Check Cached</label>
-                    </div>
-                </div>
-            </div>
-            <div class="row mt-3 webdav-${index} d-none">
-                <h6 class="pb-2">Webdav</h6>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Torrents Refresh Interval</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].torrents_refresh_interval" placeholder="15s" required>
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Download Links Refresh Interval</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].download_links_refresh_interval" placeholder="24h" required>
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Expire Links After</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].auto_expire_links_after" placeholder="24h" required>
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Folder Naming Structure</label>
-                    <select class="form-select" name="debrid[${index}].folder_naming"  disabled>
-                        <option value="filename">File name</option>
-                        <option value="filename_no_ext">File name with No Ext</option>
-                        <option value="original">Original name</option>
-                        <option value="original_no_ext">Original name with No Ext</option>
-                        <option value="id">Use ID</option>
-                    </select>
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Number of Workers</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].workers" required placeholder="e.g., 20">
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Rclone RC URL</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].rc_url" placeholder="e.g., http://localhost:9990">
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Rclone RC User</label>
-                    <input type="text" disabled class="form-control" name="debrid[${index}].rc_user">
-                </div>
-                <div class="col-md-3 mb-3">
-                    <label class="form-label">Rclone RC Password</label>
-                    <input type="password" disabled class="form-control" name="debrid[${index}].rc_pass">
-                </div>
-            </div>
-        </div>
-    `;
-
-        const arrTemplate = (index) => `
-        <div class="config-item position-relative mb-3 p-3 border rounded">
-            <div class="row">
-                <div class="col-md-4 mb-3">
-                    <label class="form-label">Name</label>
-                    <input type="text" disabled class="form-control" name="arr[${index}].name" required>
-                </div>
-                <div class="col-md-4 mb-3">
-                    <label class="form-label">Host</label>
-                    <input type="text" disabled class="form-control" name="arr[${index}].host" required>
-                </div>
-                <div class="col-md-4 mb-3">
-                    <label class="form-label">API Token</label>
-                    <input type="password" disabled class="form-control" name="arr[${index}].token" required>
-                </div>
-            </div>
-            <div class="row">
-                <div class="col-md-2 mb-3">
-                    <div class="form-check">
-                        <label class="form-check-label">Cleanup Queue</label>
-                        <input type="checkbox" disabled class="form-check-input" name="arr[${index}].cleanup">
-                    </div>
-                </div>
-                <div class="col-md-2 mb-3">
-                    <div class="form-check">
-                        <label class="form-check-label">Skip Repair</label>
-                        <input type="checkbox" disabled class="form-check-input" name="arr[${index}].skip_repair">
-                    </div>
-                </div>
-                <div class="col-md-2 mb-3">
-                    <div class="form-check">
-                        <label class="form-check-label">Download Uncached</label>
-                        <input type="checkbox" disabled class="form-check-input" name="arr[${index}].download_uncached">
-                    </div>
-                </div>
-            </div>
-        </div>
-    `;
-
-        // Main functionality
-        document.addEventListener('DOMContentLoaded', function() {
-            let debridCount = 0;
-            let arrCount = 0;
-
-            // Load existing configuration
-            fetch('/internal/config')
-                .then(response => response.json())
-                .then(config => {
-                    // Load Debrid configs
-                    config.debrids?.forEach(debrid => {
-                        addDebridConfig(debrid);
-                    });
-
-                    // Load QBitTorrent config
-                    if (config.qbittorrent) {
-                        Object.entries(config.qbittorrent).forEach(([key, value]) => {
-                            const input = document.querySelector(`[name="qbit.${key}"]`);
-                            if (input) {
-                                if (input.type === 'checkbox') {
-                                    input.checked = value;
-                                } else {
-                                    input.value = value;
-                                }
-                            }
-                        });
-                    }
-
-                    // Load Arr configs
-                    config.arrs?.forEach(arr => {
-                        addArrConfig(arr);
-                    });
-
-                    // Load Repair config
-                    if (config.repair) {
-                        Object.entries(config.repair).forEach(([key, value]) => {
-                            const input = document.querySelector(`[name="repair.${key}"]`);
-                            if (input) {
-                                if (input.type === 'checkbox') {
-                                    input.checked = value;
-                                } else {
-                                    input.value = value;
-                                }
-                            }
-                        });
-                    }
-
-                    // Load general config
-
-                    const logLevel = document.getElementById('log-level');
-                    logLevel.value = config.log_level;
-                    if (config.allowed_file_types && Array.isArray(config.allowed_file_types)) {
-                        document.querySelector('[name="allowed_file_types"]').value = config.allowed_file_types.join(', ');
-                    }
-                    if (config.min_file_size) {
-                        document.querySelector('[name="min_file_size"]').value = config.min_file_size;
-                    }
-                    if (config.max_file_size) {
-                        document.querySelector('[name="max_file_size"]').value = config.max_file_size;
-                    }
-                    if (config.discord_webhook_url) {
-                        document.querySelector('[name="discord_webhook_url"]').value = config.discord_webhook_url;
-                    }
-
-                });
-
-            // Handle form submission
-            document.getElementById('configForm').addEventListener('submit', async (e) => {
-                e.preventDefault();
-                const formData = new FormData(e.target);
-                const config = {
-                    debrids: [],
-                    qbittorrent: {},
-                    arrs: [],
-                    repair: {}
-                };
-
-                // Process form data
-                for (let [key, value] of formData.entries()) {
-                    if (key.startsWith('debrid[')) {
-                        const match = key.match(/debrid\[(\d+)\]\.(.+)/);
-                        if (match) {
-                            const [_, index, field] = match;
-                            if (!config.debrids[index]) config.debrids[index] = {};
-                            config.debrids[index][field] = value;
-                        }
-                    } else if (key.startsWith('qbit.')) {
-                        config.qbittorrent[key.replace('qbit.', '')] = value;
-                    } else if (key.startsWith('arr[')) {
-                        const match = key.match(/arr\[(\d+)\]\.(.+)/);
-                        if (match) {
-                            const [_, index, field] = match;
-                            if (!config.arrs[index]) config.arrs[index] = {};
-                            config.arrs[index][field] = value;
-                        }
-                    } else if (key.startsWith('repair.')) {
-                        config.repair[key.replace('repair.', '')] = value;
-                    }
-                }
-
-                // Clean up arrays (remove empty entries)
-                config.debrids = config.debrids.filter(Boolean);
-                config.arrs = config.arrs.filter(Boolean);
-
-                try {
-                    const response = await fetch('/internal/config', {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify(config)
-                    });
-
-                    if (!response.ok) throw new Error(await response.text());
-
-                    createToast('Configuration saved successfully!');
-                } catch (error) {
-                    createToast(`Error saving configuration: ${error.message}`, 'error');
-                }
-            });
-
-            // Helper functions
-            function addDebridConfig(data = {}) {
-                const container = document.getElementById('debridConfigs');
-                container.insertAdjacentHTML('beforeend', debridTemplate(debridCount));
-
-                if (data) {
-
-                    if (data.use_webdav) {
-                        let _webCfg = container.querySelector(`.webdav-${debridCount}`);
-                        if (_webCfg) {
-                            _webCfg.classList.remove('d-none');
-                        }
-                    }
-
-                    function setFieldValues(obj, prefix) {
-                        Object.entries(obj).forEach(([key, value]) => {
-                            const fieldName = prefix ? `${prefix}.${key}` : key;
-
-                            // If value is an object and not null, recursively process nested fields
-                            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-                                setFieldValues(value, fieldName);
-                            } else {
-                                // Handle leaf values (actual form fields)
-                                const input = container.querySelector(`[name="debrid[${debridCount}].${fieldName}"]`);
-                                if (input) {
-                                    if (input.type === 'checkbox') {
-                                        input.checked = value;
-                                    } else {
-                                        input.value = value;
-                                    }
-                                }
-                            }
-                        });
-                    }
-
-                    // Start processing with the root object
-                    setFieldValues(data, '');
-                }
-
-                debridCount++;
-            }
-
-            function addArrConfig(data = {}) {
-                const container = document.getElementById('arrConfigs');
-                container.insertAdjacentHTML('beforeend', arrTemplate(arrCount));
-
-                if (data) {
-                    Object.entries(data).forEach(([key, value]) => {
-                        const input = container.querySelector(`[name="arr[${arrCount}].${key}"]`);
-                        if (input) {
-                            if (input.type === 'checkbox') {
-                                input.checked = value;
-                            } else {
-                                input.value = value;
-                            }
-                        }
-                    });
-                }
-
-                arrCount++;
-            }
-        });
-
-
-        // Register magnet link handler
-        function registerMagnetLinkHandler() {
-            if ('registerProtocolHandler' in navigator) {
-                try {
-                    navigator.registerProtocolHandler(
-                        'magnet',
-                        `${window.location.origin}/download?magnet=%s`,
-                        'DecyphArr'
-                    );
-                    localStorage.setItem('magnetHandler', 'true');
-                    document.getElementById('registerMagnetLink').innerText = '✅ DecyphArr Can Open Magnet Links';
-                    document.getElementById('registerMagnetLink').classList.add('bg-white', 'text-black');
-                    console.log('Registered magnet link handler successfully.');
-                } catch (error) {
-                    console.error('Failed to register magnet link handler:', error);
-                }
-            }
-        }
-
-        var magnetHandler = localStorage.getItem('magnetHandler');
-        if (magnetHandler === 'true') {
-            document.getElementById('registerMagnetLink').innerText = '✅ DecyphArr Can Open Magnet Links';
-            document.getElementById('registerMagnetLink').classList.add('bg-white', 'text-black');
-        }
-    </script>
-{{ end }}

pkg/web/web/login.html

@@ -1,131 +0,0 @@
-{{ define "login" }}
-<div class="container mt-5">
-    <div class="row justify-content-center">
-        <div class="col-md-6 col-lg-4">
-            <div class="card">
-                <div class="card-header">
-                    <h4 class="mb-0 text-center">Login</h4>
-                </div>
-                <div class="card-body">
-                    <form id="loginForm">
-                        <div class="mb-3">
-                            <label for="username" class="form-label">Username</label>
-                            <input type="text" class="form-control" id="username" name="username" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="password" class="form-label">Password</label>
-                            <input type="password" class="form-control" id="password" name="password" required>
-                        </div>
-                        <div class="d-grid">
-                            <button type="submit" class="btn btn-primary">Login</button>
-                        </div>
-                    </form>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-    document.getElementById('loginForm').addEventListener('submit', async (e) => {
-        e.preventDefault();
-
-        const formData = {
-            username: document.getElementById('username').value,
-            password: document.getElementById('password').value
-        };
-
-        try {
-            const response = await fetch('/login', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(formData)
-            });
-
-            if (response.ok) {
-                window.location.href = '/';
-            } else {
-                createToast('Invalid credentials', 'error');
-            }
-        } catch (error) {
-            console.error('Login error:', error);
-            createToast('Login failed', 'error');
-        }
-    });
-</script>
-{{ end }}
-
-{{ define "setup" }}
-<div class="container mt-5">
-    <div class="row justify-content-center">
-        <div class="col-md-6 col-lg-4">
-            <div class="card">
-                <div class="card-header">
-                    <h4 class="mb-0 text-center">First Time Setup</h4>
-                </div>
-                <div class="card-body">
-                    <form id="setupForm">
-                        <div class="mb-3">
-                            <label for="username" class="form-label">Choose Username</label>
-                            <input type="text" class="form-control" id="username" name="username" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="password" class="form-label">Choose Password</label>
-                            <input type="password" class="form-control" id="password" name="password" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="confirmPassword" class="form-label">Confirm Password</label>
-                            <input type="password" class="form-control" id="confirmPassword" name="confirmPassword" required>
-                        </div>
-                        <div class="d-grid">
-                            <button type="submit" class="btn btn-primary">Set Credentials</button>
-                        </div>
-                    </form>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-    document.getElementById('setupForm').addEventListener('submit', async (e) => {
-        e.preventDefault();
-
-        const password = document.getElementById('password').value;
-        const confirmPassword = document.getElementById('confirmPassword').value;
-
-        if (password !== confirmPassword) {
-            createToast('Passwords do not match', 'error');
-            return;
-        }
-
-        const formData = {
-            username: document.getElementById('username').value,
-            password: password,
-            confirmPassword: confirmPassword
-        };
-
-        try {
-            const response = await fetch('/setup', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json'
-                },
-                body: JSON.stringify(formData)
-            });
-
-            if (response.ok) {
-                window.location.href = '/';
-            } else {
-                const error = await response.text();
-                createToast(error, 'error');
-            }
-        } catch (error) {
-            console.error('Setup error:', error);
-            createToast('Setup failed', 'error');
-        }
-    });
-</script>
-{{ end }}

pkg/web/web/setup.html

@@ -1,32 +0,0 @@
-{{ define "setup" }}
-<div class="container mt-5">
-    <div class="row justify-content-center">
-        <div class="col-md-6 col-lg-4">
-            <div class="card">
-                <div class="card-header">
-                    <h4 class="mb-0 text-center">First Time Setup</h4>
-                </div>
-                <div class="card-body">
-                    <form id="setupForm" method="POST" action="/setup">
-                        <div class="mb-3">
-                            <label for="username" class="form-label">Choose Username</label>
-                            <input type="text" class="form-control" id="username" name="username" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="password" class="form-label">Choose Password</label>
-                            <input type="password" class="form-control" id="password" name="password" required>
-                        </div>
-                        <div class="mb-3">
-                            <label for="confirmPassword" class="form-label">Confirm Password</label>
-                            <input type="password" class="form-control" id="confirmPassword" name="confirmPassword" required>
-                        </div>
-                        <div class="d-grid">
-                            <button type="submit" class="btn btn-primary">Set Credentials</button>
-                        </div>
-                    </form>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-{{ end }}

pkg/webdav/file.go

@@ -7,13 +7,13 @@ import (
 	"io"
 	"net/http"
 	"os"
+	"strings"
 	"time"
 )
 
 var sharedClient = &http.Client{
 	Transport: &http.Transport{
 		TLSClientConfig:       &tls.Config{InsecureSkipVerify: true},
-		Proxy:                 http.ProxyFromEnvironment,
 		MaxIdleConns:          100,
 		MaxIdleConnsPerHost:   20,
 		MaxConnsPerHost:       50,
@@ -23,13 +23,14 @@ var sharedClient = &http.Client{
 		ExpectContinueTimeout: 1 * time.Second,
 		DisableKeepAlives:     false,
 	},
-	Timeout: 60 * time.Second,
+	Timeout: 0,
 }
 
 type File struct {
-	cache     *debrid.Cache
-	fileId    string
-	torrentId string
+	cache       *debrid.Cache
+	fileId      string
+	torrentName string
+	torrentId   string
 
 	modTime time.Time
 
@@ -45,10 +46,9 @@ type File struct {
 
 	downloadLink string
 	link         string
+	canDelete    bool
 }
 
-// You can not download this file because you have exceeded your traffic on this hoster
-
 // File interface implementations for File
 
 func (f *File) Close() error {
@@ -59,17 +59,21 @@ func (f *File) Close() error {
 	return nil
 }
 
-func (f *File) getDownloadLink() string {
+func (f *File) getDownloadLink() (string, error) {
 	// Check if we already have a final URL cached
 
 	if f.downloadLink != "" && isValidURL(f.downloadLink) {
-		return f.downloadLink
+		return f.downloadLink, nil
+	}
+	downloadLink, err := f.cache.GetDownloadLink(f.torrentName, f.name, f.link)
+	if err != nil {
+		return "", err
 	}
-	downloadLink := f.cache.GetDownloadLink(f.torrentId, f.name, f.link)
 	if downloadLink != "" && isValidURL(downloadLink) {
-		return downloadLink
+		f.downloadLink = downloadLink
+		return downloadLink, nil
 	}
-	return ""
+	return "", os.ErrNotExist
 }
 
 func (f *File) stream() (*http.Response, error) {
@@ -80,16 +84,21 @@ func (f *File) stream() (*http.Response, error) {
 		downloadLink string
 	)
 
-	downloadLink = f.getDownloadLink() // Uses the first API key
+	downloadLink, err = f.getDownloadLink()
+	if err != nil {
+
+		_log.Trace().Msgf("Failed to get download link for %s. %s", f.name, err)
+		return nil, io.EOF
+	}
 	if downloadLink == "" {
-		_log.Error().Msgf("Failed to get download link for %s. Empty download link", f.name)
-		return nil, fmt.Errorf("failed to get download link")
+		_log.Trace().Msgf("Failed to get download link for %s. Empty download link", f.name)
+		return nil, io.EOF
 	}
 
 	req, err := http.NewRequest("GET", downloadLink, nil)
 	if err != nil {
-		_log.Error().Msgf("Failed to create HTTP request: %s", err)
-		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
+		_log.Trace().Msgf("Failed to create HTTP request: %s", err)
+		return nil, io.EOF
 	}
 
 	if f.offset > 0 {
@@ -98,22 +107,32 @@ func (f *File) stream() (*http.Response, error) {
 
 	resp, err := client.Do(req)
 	if err != nil {
-		return resp, fmt.Errorf("HTTP request error: %w", err)
+		return resp, io.EOF
 	}
 
 	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
-
+		f.downloadLink = ""
 		closeResp := func() {
 			_, _ = io.Copy(io.Discard, resp.Body)
 			resp.Body.Close()
 		}
 
 		if resp.StatusCode == http.StatusServiceUnavailable {
-			closeResp()
-			// Read the body to consume the response
-			f.cache.MarkDownloadLinkAsInvalid(f.link, downloadLink, "bandwidth_exceeded")
-			// Retry with a different API key if it's available
-			return f.stream()
+			b, _ := io.ReadAll(resp.Body)
+			err := resp.Body.Close()
+			if err != nil {
+				_log.Trace().Msgf("Failed to close response body: %s", err)
+				return nil, io.EOF
+			}
+			if strings.Contains(string(b), "You can not download this file because you have exceeded your traffic on this hoster") {
+				_log.Trace().Msgf("Bandwidth exceeded for %s. Download token will be disabled if you have more than one", f.name)
+				f.cache.MarkDownloadLinkAsInvalid(f.link, downloadLink, "bandwidth_exceeded")
+				// Retry with a different API key if it's available
+				return f.stream()
+			} else {
+				_log.Trace().Msgf("Failed to get download link for %s. %s", f.name, string(b))
+				return resp, io.EOF
+			}
 
 		} else if resp.StatusCode == http.StatusNotFound {
 			closeResp()
@@ -121,14 +140,18 @@ func (f *File) stream() (*http.Response, error) {
 			// Regenerate a new download link
 			f.cache.MarkDownloadLinkAsInvalid(f.link, downloadLink, "link_not_found")
 			// Generate a new download link
-			downloadLink = f.getDownloadLink()
+			downloadLink, err = f.getDownloadLink()
+			if err != nil {
+				_log.Trace().Msgf("Failed to get download link for %s. %s", f.name, err)
+				return nil, io.EOF
+			}
 			if downloadLink == "" {
-				_log.Error().Msgf("Failed to get download link for %s", f.name)
-				return nil, fmt.Errorf("failed to get download link")
+				_log.Trace().Msgf("Failed to get download link for %s", f.name)
+				return nil, io.EOF
 			}
 			req, err = http.NewRequest("GET", downloadLink, nil)
 			if err != nil {
-				return nil, fmt.Errorf("failed to create HTTP request: %w", err)
+				return nil, io.EOF
 			}
 			if f.offset > 0 {
 				req.Header.Set("Range", fmt.Sprintf("bytes=%d-", f.offset))
@@ -142,13 +165,13 @@ func (f *File) stream() (*http.Response, error) {
 				closeResp()
 				// Read the body to consume the response
 				f.cache.MarkDownloadLinkAsInvalid(f.link, downloadLink, "link_not_found")
-				return resp, fmt.Errorf("link not found")
+				return resp, io.EOF
 			}
 			return resp, nil
 
 		} else {
 			closeResp()
-			return resp, fmt.Errorf("unexpected HTTP status: %d", resp.StatusCode)
+			return resp, io.EOF
 		}
 
 	}
@@ -162,7 +185,6 @@ func (f *File) Read(p []byte) (n int, err error) {
 	if f.metadataOnly {
 		return 0, io.EOF
 	}
-	// If file content is preloaded, read from memory.
 	if f.content != nil {
 		if f.offset >= int64(len(f.content)) {
 			return 0, io.EOF
@@ -185,7 +207,7 @@ func (f *File) Read(p []byte) (n int, err error) {
 			return 0, err
 		}
 		if resp == nil {
-			return 0, fmt.Errorf("failed to get response")
+			return 0, io.EOF
 		}
 
 		f.reader = resp.Body
@@ -195,10 +217,7 @@ func (f *File) Read(p []byte) (n int, err error) {
 	n, err = f.reader.Read(p)
 	f.offset += int64(n)
 
-	if err == io.EOF {
-		f.reader.Close()
-		f.reader = nil
-	} else if err != nil {
+	if err != nil {
 		f.reader.Close()
 		f.reader = nil
 	}
@@ -269,10 +288,6 @@ func (f *File) ReadAt(p []byte, off int64) (n int, err error) {
 
 	// Read the data
 	n, err = f.Read(p)
-
-	// Don't restore position for Infuse compatibility
-	// Infuse expects sequential reads after the initial seek
-
 	return n, err
 }
 

pkg/webdav/file_info.go

@@ -7,6 +7,7 @@ import (
 
 // FileInfo implements os.FileInfo for our WebDAV files
 type FileInfo struct {
+	id      string
 	name    string
 	size    int64
 	mode    os.FileMode
@@ -14,9 +15,10 @@ type FileInfo struct {
 	isDir   bool
 }
 
-func (fi *FileInfo) Name() string       { return fi.name }
+func (fi *FileInfo) Name() string       { return fi.name } // uses minimal escaping
 func (fi *FileInfo) Size() int64        { return fi.size }
 func (fi *FileInfo) Mode() os.FileMode  { return fi.mode }
 func (fi *FileInfo) ModTime() time.Time { return fi.modTime }
 func (fi *FileInfo) IsDir() bool        { return fi.isDir }
+func (fi *FileInfo) ID() string         { return fi.id }
 func (fi *FileInfo) Sys() interface{}   { return nil }

pkg/webdav/handler.go

@@ -1,40 +1,41 @@
 package webdav
 
 import (
-	"bytes"
 	"context"
 	"fmt"
+	"io"
+	"mime"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"slices"
+	"strings"
+	"time"
+
 	"github.com/rs/zerolog"
-	"github.com/sirrobot01/decypharr/internal/request"
+	"github.com/sirrobot01/decypharr/internal/utils"
 	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
 	"github.com/sirrobot01/decypharr/pkg/debrid/types"
 	"github.com/sirrobot01/decypharr/pkg/version"
 	"golang.org/x/net/webdav"
-	"html/template"
-	"io"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"os"
-	path "path/filepath"
-	"slices"
-	"strings"
-	"time"
 )
 
 type Handler struct {
 	Name     string
 	logger   zerolog.Logger
 	cache    *debrid.Cache
+	URLBase  string
 	RootPath string
 }
 
-func NewHandler(name string, cache *debrid.Cache, logger zerolog.Logger) *Handler {
+func NewHandler(name, urlBase string, cache *debrid.Cache, logger zerolog.Logger) *Handler {
 	h := &Handler{
 		Name:     name,
 		cache:    cache,
 		logger:   logger,
-		RootPath: fmt.Sprintf("/%s", name),
+		URLBase:  urlBase,
+		RootPath: path.Join(urlBase, "webdav", name),
 	}
 	return h
 }
@@ -44,24 +45,74 @@ func (h *Handler) Mkdir(ctx context.Context, name string, perm os.FileMode) erro
 	return os.ErrPermission // Read-only filesystem
 }
 
+func (h *Handler) readinessMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		select {
+		case <-h.cache.IsReady():
+			// WebDAV is ready, proceed
+			next.ServeHTTP(w, r)
+		default:
+			// WebDAV is still initializing
+			w.Header().Set("Retry-After", "5")
+			http.Error(w, "WebDAV service is initializing, please try again shortly", http.StatusServiceUnavailable)
+		}
+	})
+}
+
 // RemoveAll implements webdav.FileSystem
 func (h *Handler) RemoveAll(ctx context.Context, name string) error {
-	name = path.Clean("/" + name)
-
-	rootDir := h.getRootPath()
+	if !strings.HasPrefix(name, "/") {
+		name = "/" + name
+	}
+	name = utils.PathUnescape(path.Clean(name))
+	rootDir := path.Clean(h.RootPath)
 
 	if name == rootDir {
 		return os.ErrPermission
 	}
 
-	torrentName, _ := getName(rootDir, name)
-	cachedTorrent := h.cache.GetTorrentByName(torrentName)
-	if cachedTorrent == nil {
-		h.logger.Debug().Msgf("Torrent not found: %s", torrentName)
-		return nil // It's possible that the torrent was removed
+	// Skip if it's version.txt
+	if name == path.Join(rootDir, "version.txt") {
+		return os.ErrPermission
+	}
+
+	// Check if the name is a parent path
+	if _, ok := h.isParentPath(name); ok {
+		return os.ErrPermission
+	}
+
+	// Check if the name is a torrent folder
+	rel := strings.TrimPrefix(name, rootDir+"/")
+	parts := strings.Split(rel, "/")
+	if len(parts) == 2 && utils.Contains(h.getParentItems(), parts[0]) {
+		torrentName := parts[1]
+		torrent := h.cache.GetTorrentByName(torrentName)
+		if torrent == nil {
+			return os.ErrNotExist
+		}
+		// Remove the torrent from the cache and debrid
+		h.cache.OnRemove(torrent.Id)
+		return nil
+	}
+	// If we reach here, it means the path is a file
+	if len(parts) >= 2 {
+		if utils.Contains(h.getParentItems(), parts[0]) {
+			torrentName := parts[1]
+			cached := h.cache.GetTorrentByName(torrentName)
+			if cached != nil && len(parts) >= 3 {
+				filename := filepath.Clean(path.Join(parts[2:]...))
+				if file, ok := cached.GetFile(filename); ok {
+					if err := h.cache.RemoveFile(cached.Id, file.Name); err != nil {
+						h.logger.Error().Err(err).Msgf("Failed to remove file %s from torrent %s", file.Name, torrentName)
+						return err
+					}
+					// If the file was successfully removed, we can return nil
+					return nil
+				}
+			}
+		}
 	}
 
-	h.cache.OnRemove(cachedTorrent.Id)
 	return nil
 }
 
@@ -70,16 +121,19 @@ func (h *Handler) Rename(ctx context.Context, oldName, newName string) error {
 	return os.ErrPermission // Read-only filesystem
 }
 
-func (h *Handler) getRootPath() string {
-	return fmt.Sprintf("/webdav/%s", h.Name)
-}
-
-func (h *Handler) getTorrentsFolders() []os.FileInfo {
-	return h.cache.GetListing()
+func (h *Handler) getTorrentsFolders(folder string) []os.FileInfo {
+	return h.cache.GetListing(folder)
 }
 
 func (h *Handler) getParentItems() []string {
-	return []string{"__all__", "torrents", "version.txt"}
+	parents := []string{"__all__", "torrents", "__bad__"}
+
+	// Add custom folders
+	parents = append(parents, h.cache.GetCustomFolders()...)
+
+	// version.txt
+	parents = append(parents, "version.txt")
+	return parents
 }
 
 func (h *Handler) getParentFiles() []os.FileInfo {
@@ -95,37 +149,53 @@ func (h *Handler) getParentFiles() []os.FileInfo {
 		}
 		if item == "version.txt" {
 			f.isDir = false
-			versionInfo := version.GetInfo().String()
-			f.size = int64(len(versionInfo))
+			f.size = int64(len(version.GetInfo().String()))
 		}
 		rootFiles = append(rootFiles, f)
 	}
 	return rootFiles
 }
 
-func (h *Handler) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
-	name = path.Clean("/" + name)
-	rootDir := h.getRootPath()
+// returns the os.FileInfo slice for “depth-1” children of cleanPath
+func (h *Handler) getChildren(name string) []os.FileInfo {
 
-	metadataOnly := false
-	if ctx.Value("metadataOnly") != nil {
-		metadataOnly = true
+	if name[0] != '/' {
+		name = "/" + name
 	}
+	name = utils.PathUnescape(path.Clean(name))
+	root := path.Clean(h.RootPath)
 
+	// top‐level “parents” (e.g. __all__, torrents etc)
+	if name == root {
+		return h.getParentFiles()
+	}
+	// one level down (e.g. /root/parentFolder)
+	if parent, ok := h.isParentPath(name); ok {
+		return h.getTorrentsFolders(parent)
+	}
+	// torrent-folder level (e.g. /root/parentFolder/torrentName)
+	rel := strings.TrimPrefix(name, root+"/")
+	parts := strings.Split(rel, "/")
+	if len(parts) == 2 && utils.Contains(h.getParentItems(), parts[0]) {
+		torrentName := parts[1]
+		if t := h.cache.GetTorrentByName(torrentName); t != nil {
+			return h.getFileInfos(t.Torrent)
+		}
+	}
+	return nil
+}
+
+func (h *Handler) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
+	if !strings.HasPrefix(name, "/") {
+		name = "/" + name
+	}
+	name = utils.PathUnescape(path.Clean(name))
+	rootDir := path.Clean(h.RootPath)
+	metadataOnly := ctx.Value("metadataOnly") != nil
 	now := time.Now()
 
-	// Fast path optimization with a map lookup instead of string comparisons
-	switch name {
-	case rootDir:
-		return &File{
-			cache:        h.cache,
-			isDir:        true,
-			children:     h.getParentFiles(),
-			name:         "/",
-			metadataOnly: metadataOnly,
-			modTime:      now,
-		}, nil
-	case path.Join(rootDir, "version.txt"):
+	// 1) special case version.txt
+	if name == path.Join(rootDir, "version.txt") {
 		versionInfo := version.GetInfo().String()
 		return &File{
 			cache:        h.cache,
@@ -138,66 +208,47 @@ func (h *Handler) OpenFile(ctx context.Context, name string, flag int, perm os.F
 		}, nil
 	}
 
-	// Single check for top-level folders
-	if h.isParentPath(name) {
-		folderName := strings.TrimPrefix(name, rootDir)
-		folderName = strings.TrimPrefix(folderName, "/")
-
-		// Only fetch the torrent folders once
-		children := h.getTorrentsFolders()
-
+	// 2) directory case: ask getChildren
+	if children := h.getChildren(name); children != nil {
+		displayName := filepath.Clean(path.Base(name))
+		if name == rootDir {
+			displayName = "/"
+		}
 		return &File{
 			cache:        h.cache,
 			isDir:        true,
 			children:     children,
-			name:         folderName,
+			name:         displayName,
 			size:         0,
 			metadataOnly: metadataOnly,
 			modTime:      now,
 		}, nil
 	}
 
-	_path := strings.TrimPrefix(name, rootDir)
-	parts := strings.Split(strings.TrimPrefix(_path, "/"), "/")
-
-	if len(parts) >= 2 && (slices.Contains(h.getParentItems(), parts[0])) {
-
-		torrentName := parts[1]
-		cachedTorrent := h.cache.GetTorrentByName(torrentName)
-		if cachedTorrent == nil {
-			h.logger.Debug().Msgf("Torrent not found: %s", torrentName)
-			return nil, os.ErrNotExist
-		}
-
-		if len(parts) == 2 {
-			// Torrent folder level
-			return &File{
-				cache:        h.cache,
-				torrentId:    cachedTorrent.Id,
-				isDir:        true,
-				children:     h.getFileInfos(cachedTorrent.Torrent),
-				name:         cachedTorrent.Name,
-				size:         cachedTorrent.Size,
-				metadataOnly: metadataOnly,
-				modTime:      cachedTorrent.AddedOn,
-			}, nil
-		}
-
-		// Torrent file level
-		filename := strings.Join(parts[2:], "/")
-		if file, ok := cachedTorrent.Files[filename]; ok {
-			fi := &File{
-				cache:        h.cache,
-				torrentId:    cachedTorrent.Id,
-				fileId:       file.Id,
-				isDir:        false,
-				name:         file.Name,
-				size:         file.Size,
-				link:         file.Link,
-				metadataOnly: metadataOnly,
-				modTime:      cachedTorrent.AddedOn,
+	// 3) file‐within‐torrent case
+	// everything else must be a file under a torrent folder
+	rel := strings.TrimPrefix(name, rootDir+"/")
+	parts := strings.Split(rel, "/")
+	if len(parts) >= 2 {
+		if utils.Contains(h.getParentItems(), parts[0]) {
+			torrentName := parts[1]
+			cached := h.cache.GetTorrentByName(torrentName)
+			if cached != nil && len(parts) >= 3 {
+				filename := filepath.Clean(path.Join(parts[2:]...))
+				if file, ok := cached.GetFile(filename); ok && !file.Deleted {
+					return &File{
+						cache:        h.cache,
+						torrentName:  torrentName,
+						fileId:       file.Id,
+						isDir:        false,
+						name:         file.Name,
+						size:         file.Size,
+						link:         file.Link,
+						metadataOnly: metadataOnly,
+						modTime:      cached.AddedOn,
+					}, nil
+				}
 			}
-			return fi, nil
 		}
 	}
 
@@ -215,9 +266,20 @@ func (h *Handler) Stat(ctx context.Context, name string) (os.FileInfo, error) {
 }
 
 func (h *Handler) getFileInfos(torrent *types.Torrent) []os.FileInfo {
-	files := make([]os.FileInfo, 0, len(torrent.Files))
+	torrentFiles := torrent.GetFiles()
+	files := make([]os.FileInfo, 0, len(torrentFiles))
 	now := time.Now()
-	for _, file := range torrent.Files {
+
+	// Sort by file name since the order is lost when using the map
+	sortedFiles := make([]*types.File, 0, len(torrentFiles))
+	for _, file := range torrentFiles {
+		sortedFiles = append(sortedFiles, &file)
+	}
+	slices.SortFunc(sortedFiles, func(a, b *types.File) int {
+		return strings.Compare(a.Name, b.Name)
+	})
+
+	for _, file := range sortedFiles {
 		files = append(files, &FileInfo{
 			name:    file.Name,
 			size:    file.Size,
@@ -231,132 +293,31 @@ func (h *Handler) getFileInfos(torrent *types.Torrent) []os.FileInfo {
 
 func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
-	// Handle OPTIONS
-	if r.Method == "OPTIONS" {
-		w.WriteHeader(http.StatusOK)
+	switch r.Method {
+	case "GET":
+		h.handleGet(w, r)
 		return
-	}
-
-	// Cache PROPFIND responses for a short time to reduce load.
-	if r.Method == "PROPFIND" {
-		// Determine the Depth; default to "1" if not provided.
-		// Set metadata only
-		ctx := context.WithValue(r.Context(), "metadataOnly", true)
-		r = r.WithContext(ctx)
-		cleanPath := path.Clean(r.URL.Path)
-		depth := r.Header.Get("Depth")
-		if depth == "" {
-			depth = "1"
-		}
-		// Use both path and Depth header to form the cache key.
-		cacheKey := fmt.Sprintf("propfind:%s:%s", cleanPath, depth)
-
-		// Determine TTL based on the requested folder:
-		// - If the path is exactly the parent folder (which changes frequently),
-		//   use a short TTL.
-		// - Otherwise, for deeper (torrent folder) paths, use a longer TTL.
-		ttl := 30 * time.Minute
-		if h.isParentPath(r.URL.Path) {
-			ttl = 30 * time.Second
-		}
-
-		if served := h.serveFromCacheIfValid(w, r, cacheKey, ttl); served {
-			return
-		}
-
-		// No valid cache entry; process the PROPFIND request.
-		responseRecorder := httptest.NewRecorder()
-		handler := &webdav.Handler{
-			FileSystem: h,
-			LockSystem: webdav.NewMemLS(),
-			Logger: func(r *http.Request, err error) {
-				if err != nil {
-					h.logger.Error().Err(err).Msg("WebDAV error")
-				}
-			},
-		}
-		handler.ServeHTTP(responseRecorder, r)
-		responseData := responseRecorder.Body.Bytes()
-		gzippedData := request.Gzip(responseData)
-
-		// Create compressed version
-
-		h.cache.PropfindResp.Store(cacheKey, debrid.PropfindResponse{
-			Data:        responseData,
-			GzippedData: gzippedData,
-			Ts:          time.Now(),
-		})
-
-		// Forward the captured response to the client.
-		for k, v := range responseRecorder.Header() {
-			w.Header()[k] = v
-		}
-
-		if acceptsGzip(r) {
-			w.Header().Set("Content-Encoding", "gzip")
-			w.Header().Set("Vary", "Accept-Encoding")
-			w.Header().Set("Content-Length", fmt.Sprintf("%d", len(gzippedData)))
-			w.WriteHeader(responseRecorder.Code)
-			_, _ = w.Write(gzippedData)
-		} else {
-			w.Header().Set("Content-Length", fmt.Sprintf("%d", len(responseData)))
-			w.WriteHeader(responseRecorder.Code)
-			_, _ = w.Write(responseData)
-		}
+	case "HEAD":
+		h.handleHead(w, r)
 		return
-	}
-
-	// Handle GET requests for file/directory content
-	if r.Method == "GET" {
-		f, err := h.OpenFile(r.Context(), r.URL.Path, os.O_RDONLY, 0)
-		if err != nil {
-			h.logger.Debug().Err(err).Str("path", r.URL.Path).Msg("Failed to open file")
-			http.NotFound(w, r)
-			return
-		}
-		defer f.Close()
-
-		fi, err := f.Stat()
-		if err != nil {
-			h.logger.Error().Err(err).Msg("Failed to stat file")
-			http.Error(w, "Server Error", http.StatusInternalServerError)
-			return
-		}
-
-		// If the target is a directory, use your directory listing logic.
-		if fi.IsDir() {
-			h.serveDirectory(w, r, f)
-			return
-		}
-
-		rs, ok := f.(io.ReadSeeker)
-		if !ok {
-			// If not, read the entire file into memory as a fallback.
-			buf, err := io.ReadAll(f)
-			if err != nil {
-				h.logger.Error().Err(err).Msg("Failed to read file content")
-				http.Error(w, "Server Error", http.StatusInternalServerError)
-				return
-			}
-			rs = bytes.NewReader(buf)
-		}
-		fileName := fi.Name()
-		contentType := getContentType(fileName)
-		w.Header().Set("Content-Type", contentType)
-
-		// Serve the file with the correct modification time.
-		// http.ServeContent automatically handles Range requests.
-		http.ServeContent(w, r, fileName, fi.ModTime(), rs)
+	case "OPTIONS":
+		h.handleOptions(w, r)
 		return
+	case "PROPFIND":
+		h.handlePropfind(w, r)
+		return
+	case "DELETE":
+		if err := h.handleIDDelete(w, r); err == nil {
+			return
+		}
+		// fallthrough to default
 	}
-
-	// Fallback: for other methods, use the standard WebDAV handler.
 	handler := &webdav.Handler{
 		FileSystem: h,
 		LockSystem: webdav.NewMemLS(),
 		Logger: func(r *http.Request, err error) {
 			if err != nil {
-				h.logger.Error().
+				h.logger.Trace().
 					Err(err).
 					Str("method", r.Method).
 					Str("path", r.URL.Path).
@@ -365,6 +326,7 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		},
 	}
 	handler.ServeHTTP(w, r)
+	return
 }
 
 func getContentType(fileName string) string {
@@ -392,41 +354,15 @@ func getContentType(fileName string) string {
 	return contentType
 }
 
-func (h *Handler) isParentPath(_path string) bool {
-	rootPath := h.getRootPath()
+func (h *Handler) isParentPath(urlPath string) (string, bool) {
 	parents := h.getParentItems()
+	lastComponent := path.Base(urlPath)
 	for _, p := range parents {
-		if path.Clean(_path) == path.Clean(path.Join(rootPath, p)) {
-			return true
+		if p == lastComponent {
+			return p, true
 		}
 	}
-	return false
-}
-
-func (h *Handler) serveFromCacheIfValid(w http.ResponseWriter, r *http.Request, cacheKey string, ttl time.Duration) bool {
-	respCache, ok := h.cache.PropfindResp.Load(cacheKey)
-	if !ok {
-		return false
-	}
-
-	if time.Since(respCache.Ts) >= ttl {
-		// Remove expired cache entry
-		return false
-	}
-	w.Header().Set("Content-Type", "application/xml; charset=utf-8")
-
-	if acceptsGzip(r) && len(respCache.GzippedData) > 0 {
-		w.Header().Set("Content-Encoding", "gzip")
-		w.Header().Set("Vary", "Accept-Encoding")
-		w.Header().Set("Content-Length", fmt.Sprintf("%d", len(respCache.GzippedData)))
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(respCache.GzippedData)
-	} else {
-		w.Header().Set("Content-Length", fmt.Sprintf("%d", len(respCache.Data)))
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(respCache.Data)
-	}
-	return true
+	return "", false
 }
 
 func (h *Handler) serveDirectory(w http.ResponseWriter, r *http.Request, file webdav.File) {
@@ -446,6 +382,8 @@ func (h *Handler) serveDirectory(w http.ResponseWriter, r *http.Request, file we
 	cleanPath := path.Clean(r.URL.Path)
 	parentPath := path.Dir(cleanPath)
 	showParent := cleanPath != "/" && parentPath != "." && parentPath != cleanPath
+	isBadPath := strings.HasSuffix(cleanPath, "__bad__")
+	_, canDelete := h.isParentPath(cleanPath)
 
 	// Prepare template data
 	data := struct {
@@ -453,72 +391,167 @@ func (h *Handler) serveDirectory(w http.ResponseWriter, r *http.Request, file we
 		ParentPath string
 		ShowParent bool
 		Children   []os.FileInfo
+		URLBase    string
+		IsBadPath  bool
+		CanDelete  bool
 	}{
 		Path:       cleanPath,
 		ParentPath: parentPath,
 		ShowParent: showParent,
 		Children:   children,
-	}
-
-	// Parse and execute template
-	funcMap := template.FuncMap{
-		"add": func(a, b int) int {
-			return a + b
-		},
-		"urlpath": func(p string) string {
-			segments := strings.Split(p, "/")
-			for i, segment := range segments {
-				segments[i] = url.PathEscape(segment)
-			}
-			return strings.Join(segments, "/")
-		},
-		"formatSize": func(bytes int64) string {
-			const (
-				KB = 1024
-				MB = 1024 * KB
-				GB = 1024 * MB
-				TB = 1024 * GB
-			)
-
-			var size float64
-			var unit string
-
-			switch {
-			case bytes >= TB:
-				size = float64(bytes) / TB
-				unit = "TB"
-			case bytes >= GB:
-				size = float64(bytes) / GB
-				unit = "GB"
-			case bytes >= MB:
-				size = float64(bytes) / MB
-				unit = "MB"
-			case bytes >= KB:
-				size = float64(bytes) / KB
-				unit = "KB"
-			default:
-				size = float64(bytes)
-				unit = "bytes"
-			}
-
-			// Format to 2 decimal places for larger units, no decimals for bytes
-			if unit == "bytes" {
-				return fmt.Sprintf("%.0f %s", size, unit)
-			}
-			return fmt.Sprintf("%.2f %s", size, unit)
-		},
-	}
-	tmpl, err := template.New("directory").Funcs(funcMap).Parse(directoryTemplate)
-	if err != nil {
-		h.logger.Error().Err(err).Msg("Failed to parse directory template")
-		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-		return
+		URLBase:    h.URLBase,
+		IsBadPath:  isBadPath,
+		CanDelete:  canDelete,
 	}
 
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if err := tmpl.Execute(w, data); err != nil {
-		h.logger.Error().Err(err).Msg("Failed to execute directory template")
-		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+	if err := tplDirectory.ExecuteTemplate(w, "directory.html", data); err != nil {
 		return
 	}
 }
+
+func (h *Handler) handleGet(w http.ResponseWriter, r *http.Request) {
+	fRaw, err := h.OpenFile(r.Context(), r.URL.Path, os.O_RDONLY, 0)
+	if err != nil {
+		h.logger.Error().Err(err).
+			Str("path", r.URL.Path).
+			Msg("Failed to open file")
+		http.NotFound(w, r)
+		return
+	}
+	defer func(fRaw webdav.File) {
+		err := fRaw.Close()
+		if err != nil {
+			h.logger.Error().Err(err).Msg("Failed to close file")
+			return
+		}
+	}(fRaw)
+
+	fi, err := fRaw.Stat()
+	if err != nil {
+		h.logger.Error().Err(err).Msg("Failed to stat file")
+		http.Error(w, "Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	// If the target is a directory, use your directory listing logic.
+	if fi.IsDir() {
+		h.serveDirectory(w, r, fRaw)
+		return
+	}
+
+	// Checks if the file is a torrent file
+	// .content is nil if the file is a torrent file
+	// .content means file is preloaded, e.g version.txt
+	if file, ok := fRaw.(*File); ok && file.content == nil {
+		link, err := file.getDownloadLink()
+		if err != nil {
+			h.logger.Debug().
+				Err(err).
+				Str("link", file.link).
+				Str("path", r.URL.Path).
+				Msg("Could not fetch download link")
+			http.Error(w, "Could not fetch download link", http.StatusPreconditionFailed)
+			return
+		}
+		if link == "" {
+			http.NotFound(w, r)
+			return
+		}
+		file.downloadLink = link
+		if h.cache.StreamWithRclone() {
+			// Redirect to the download link
+			http.Redirect(w, r, file.downloadLink, http.StatusTemporaryRedirect)
+			return
+		}
+	}
+
+	// ETags
+	etag := fmt.Sprintf("\"%x-%x\"", fi.ModTime().Unix(), fi.Size())
+	w.Header().Set("ETag", etag)
+
+	// 7. Content-Type by extension
+	ext := filepath.Ext(fi.Name())
+	contentType := mime.TypeByExtension(ext)
+	if contentType == "" {
+		contentType = "application/octet-stream"
+	}
+	w.Header().Set("Content-Type", contentType)
+
+	rs, ok := fRaw.(io.ReadSeeker)
+	if !ok {
+		if r.Header.Get("Range") != "" {
+			http.Error(w, "Range not supported", http.StatusRequestedRangeNotSatisfiable)
+			return
+		}
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", fi.Size()))
+		w.Header().Set("Last-Modified", fi.ModTime().UTC().Format(http.TimeFormat))
+		w.Header().Set("Accept-Ranges", "bytes")
+		ctx := r.Context()
+		done := make(chan struct{})
+		go func() {
+			defer close(done)
+			io.Copy(w, fRaw)
+		}()
+		select {
+		case <-ctx.Done():
+			h.logger.Debug().Msg("Client cancelled download")
+			return
+		case <-done:
+		}
+		return
+	}
+	http.ServeContent(w, r, fi.Name(), fi.ModTime(), rs)
+}
+
+func (h *Handler) handleHead(w http.ResponseWriter, r *http.Request) {
+	f, err := h.OpenFile(r.Context(), r.URL.Path, os.O_RDONLY, 0)
+	if err != nil {
+		h.logger.Error().Err(err).Str("path", r.URL.Path).Msg("Failed to open file")
+		http.NotFound(w, r)
+		return
+	}
+	defer func(f webdav.File) {
+		err := f.Close()
+		if err != nil {
+			return
+		}
+	}(f)
+
+	fi, err := f.Stat()
+	if err != nil {
+		h.logger.Error().Err(err).Msg("Failed to stat file")
+		http.Error(w, "Server Error", http.StatusInternalServerError)
+		return
+	}
+	w.Header().Set("Content-Type", getContentType(fi.Name()))
+	w.Header().Set("Content-Length", fmt.Sprintf("%d", fi.Size()))
+	w.Header().Set("Last-Modified", fi.ModTime().UTC().Format(http.TimeFormat))
+	w.Header().Set("Accept-Ranges", "bytes")
+	w.WriteHeader(http.StatusOK)
+}
+
+func (h *Handler) handleOptions(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Allow", "OPTIONS, GET, HEAD, PUT, DELETE, MKCOL, COPY, MOVE, PROPFIND")
+	w.Header().Set("DAV", "1, 2")
+	w.WriteHeader(http.StatusOK)
+}
+
+// handleDelete deletes a torrent from using id
+func (h *Handler) handleIDDelete(w http.ResponseWriter, r *http.Request) error {
+	cleanPath := path.Clean(r.URL.Path) // Remove any leading slashes
+
+	_, torrentId := path.Split(cleanPath)
+	if torrentId == "" {
+		return os.ErrNotExist
+	}
+
+	cachedTorrent := h.cache.GetTorrent(torrentId)
+	if cachedTorrent == nil {
+		return os.ErrNotExist
+	}
+
+	h.cache.OnRemove(cachedTorrent.Id)
+	w.WriteHeader(http.StatusNoContent)
+	return nil
+}

pkg/webdav/misc.go

@@ -1,24 +1,24 @@
 package webdav
 
 import (
+	"github.com/stanNthe5/stringbuf"
 	"net/http"
 	"net/url"
+	"os"
+	"path"
+	"strconv"
 	"strings"
+	"time"
 )
 
 // getName: Returns the torrent name and filename from the path
-// /webdav/alldebrid/__all__/TorrentName
 func getName(rootDir, path string) (string, string) {
 	path = strings.TrimPrefix(path, rootDir)
-	parts := strings.Split(strings.TrimPrefix(path, "/"), "/")
+	parts := strings.Split(strings.TrimPrefix(path, string(os.PathSeparator)), string(os.PathSeparator))
 	if len(parts) < 2 {
 		return "", ""
 	}
-	return parts[1], strings.Join(parts[2:], "/") // Note the change from [0] to [1]
-}
-
-func acceptsGzip(r *http.Request) bool {
-	return strings.Contains(r.Header.Get("Accept-Encoding"), "gzip")
+	return parts[1], strings.Join(parts[2:], string(os.PathSeparator)) // Note the change from [0] to [1]
 }
 
 func isValidURL(str string) bool {
@@ -26,3 +26,121 @@ func isValidURL(str string) bool {
 	// A valid URL should parse without error, and have a non-empty scheme and host.
 	return err == nil && u.Scheme != "" && u.Host != ""
 }
+
+var pctHex = "0123456789ABCDEF"
+
+// fastEscapePath returns a percent-encoded path, preserving '/'
+// and only encoding bytes outside the unreserved set:
+//
+//	ALPHA / DIGIT / '-' / '_' / '.' / '~' / '/'
+func fastEscapePath(p string) string {
+	var b strings.Builder
+
+	for i := 0; i < len(p); i++ {
+		c := p[i]
+		// unreserved (plus '/')
+		if (c >= 'a' && c <= 'z') ||
+			(c >= 'A' && c <= 'Z') ||
+			(c >= '0' && c <= '9') ||
+			c == '-' || c == '_' ||
+			c == '.' || c == '~' ||
+			c == '/' {
+			b.WriteByte(c)
+		} else {
+			b.WriteByte('%')
+			b.WriteByte(pctHex[c>>4])
+			b.WriteByte(pctHex[c&0xF])
+		}
+	}
+	return b.String()
+}
+
+type entry struct {
+	escHref string // already XML-safe + percent-escaped
+	escName string
+	size    int64
+	isDir   bool
+	modTime string
+}
+
+func filesToXML(urlPath string, fi os.FileInfo, children []os.FileInfo) stringbuf.StringBuf {
+
+	now := time.Now().UTC().Format("2006-01-02T15:04:05.000-07:00")
+	entries := make([]entry, 0, len(children)+1)
+
+	// Add the current file itself
+	entries = append(entries, entry{
+		escHref: xmlEscape(fastEscapePath(urlPath)),
+		escName: xmlEscape(fi.Name()),
+		isDir:   fi.IsDir(),
+		size:    fi.Size(),
+		modTime: fi.ModTime().Format("2006-01-02T15:04:05.000-07:00"),
+	})
+	for _, info := range children {
+
+		nm := info.Name()
+		// build raw href
+		href := path.Join("/", urlPath, nm)
+		if info.IsDir() {
+			href += "/"
+		}
+
+		entries = append(entries, entry{
+			escHref: xmlEscape(fastEscapePath(href)),
+			escName: xmlEscape(nm),
+			isDir:   info.IsDir(),
+			size:    info.Size(),
+			modTime: info.ModTime().Format("2006-01-02T15:04:05.000-07:00"),
+		})
+	}
+
+	sb := builderPool.Get().(stringbuf.StringBuf)
+	sb.Reset()
+	defer builderPool.Put(sb)
+
+	// XML header and main element
+	_, _ = sb.WriteString(`<?xml version="1.0" encoding="UTF-8"?>`)
+	_, _ = sb.WriteString(`<d:multistatus xmlns:d="DAV:">`)
+
+	// Add responses for each entry
+	for _, e := range entries {
+		_, _ = sb.WriteString(`<d:response>`)
+		_, _ = sb.WriteString(`<d:href>`)
+		_, _ = sb.WriteString(e.escHref)
+		_, _ = sb.WriteString(`</d:href>`)
+		_, _ = sb.WriteString(`<d:propstat>`)
+		_, _ = sb.WriteString(`<d:prop>`)
+
+		if e.isDir {
+			_, _ = sb.WriteString(`<d:resourcetype><d:collection/></d:resourcetype>`)
+		} else {
+			_, _ = sb.WriteString(`<d:resourcetype/>`)
+			_, _ = sb.WriteString(`<d:getcontentlength>`)
+			_, _ = sb.WriteString(strconv.FormatInt(e.size, 10))
+			_, _ = sb.WriteString(`</d:getcontentlength>`)
+		}
+
+		_, _ = sb.WriteString(`<d:getlastmodified>`)
+		_, _ = sb.WriteString(now)
+		_, _ = sb.WriteString(`</d:getlastmodified>`)
+
+		_, _ = sb.WriteString(`<d:displayname>`)
+		_, _ = sb.WriteString(e.escName)
+		_, _ = sb.WriteString(`</d:displayname>`)
+
+		_, _ = sb.WriteString(`</d:prop>`)
+		_, _ = sb.WriteString(`<d:status>HTTP/1.1 200 OK</d:status>`)
+		_, _ = sb.WriteString(`</d:propstat>`)
+		_, _ = sb.WriteString(`</d:response>`)
+	}
+
+	// Close root element
+	_, _ = sb.WriteString(`</d:multistatus>`)
+	return sb
+}
+
+func writeXml(w http.ResponseWriter, status int, buf stringbuf.StringBuf) {
+	w.Header().Set("Content-Type", "application/xml; charset=utf-8")
+	w.WriteHeader(status)
+	_, _ = w.Write(buf.Bytes())
+}

pkg/webdav/propfind.go

@@ -0,0 +1,161 @@
+package webdav
+
+import (
+	"context"
+	"github.com/stanNthe5/stringbuf"
+	"net/http"
+	"os"
+	"path"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+var builderPool = sync.Pool{
+
+	New: func() interface{} {
+		buf := stringbuf.New("")
+		return buf
+	},
+}
+
+func (h *Handler) handlePropfind(w http.ResponseWriter, r *http.Request) {
+	// Setup context for metadata only
+	ctx := context.WithValue(r.Context(), "metadataOnly", true)
+	r = r.WithContext(ctx)
+
+	cleanPath := path.Clean(r.URL.Path)
+
+	// Build the list of entries
+	type entry struct {
+		escHref string // already XML-safe + percent-escaped
+		escName string
+		size    int64
+		isDir   bool
+		modTime string
+	}
+
+	// Always include the resource itself
+	f, err := h.OpenFile(r.Context(), cleanPath, os.O_RDONLY, 0)
+	if err != nil {
+		h.logger.Error().Err(err).Str("path", cleanPath).Msg("Failed to open file")
+		http.NotFound(w, r)
+		return
+	}
+	defer f.Close()
+
+	fi, err := f.Stat()
+	if err != nil {
+		h.logger.Error().Err(err).Msg("Failed to stat file")
+		http.Error(w, "Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	var rawEntries []os.FileInfo
+	if fi.IsDir() {
+		rawEntries = append(rawEntries, h.getChildren(cleanPath)...)
+	}
+
+	now := time.Now().UTC().Format("2006-01-02T15:04:05.000-07:00")
+	entries := make([]entry, 0, len(rawEntries)+1)
+	// Add the current file itself
+	entries = append(entries, entry{
+		escHref: xmlEscape(fastEscapePath(cleanPath)),
+		escName: xmlEscape(fi.Name()),
+		isDir:   fi.IsDir(),
+		size:    fi.Size(),
+		modTime: fi.ModTime().Format("2006-01-02T15:04:05.000-07:00"),
+	})
+	for _, info := range rawEntries {
+
+		nm := info.Name()
+		// build raw href
+		href := path.Join("/", cleanPath, nm)
+		if info.IsDir() {
+			href += "/"
+		}
+
+		entries = append(entries, entry{
+			escHref: xmlEscape(fastEscapePath(href)),
+			escName: xmlEscape(nm),
+			isDir:   info.IsDir(),
+			size:    info.Size(),
+			modTime: info.ModTime().Format("2006-01-02T15:04:05.000-07:00"),
+		})
+	}
+
+	sb := builderPool.Get().(stringbuf.StringBuf)
+	sb.Reset()
+	defer builderPool.Put(sb)
+
+	// XML header and main element
+	_, _ = sb.WriteString(`<?xml version="1.0" encoding="UTF-8"?>`)
+	_, _ = sb.WriteString(`<d:multistatus xmlns:d="DAV:">`)
+
+	// Add responses for each entry
+	for _, e := range entries {
+		_, _ = sb.WriteString(`<d:response>`)
+		_, _ = sb.WriteString(`<d:href>`)
+		_, _ = sb.WriteString(e.escHref)
+		_, _ = sb.WriteString(`</d:href>`)
+		_, _ = sb.WriteString(`<d:propstat>`)
+		_, _ = sb.WriteString(`<d:prop>`)
+
+		if e.isDir {
+			_, _ = sb.WriteString(`<d:resourcetype><d:collection/></d:resourcetype>`)
+		} else {
+			_, _ = sb.WriteString(`<d:resourcetype/>`)
+			_, _ = sb.WriteString(`<d:getcontentlength>`)
+			_, _ = sb.WriteString(strconv.FormatInt(e.size, 10))
+			_, _ = sb.WriteString(`</d:getcontentlength>`)
+		}
+
+		_, _ = sb.WriteString(`<d:getlastmodified>`)
+		_, _ = sb.WriteString(now)
+		_, _ = sb.WriteString(`</d:getlastmodified>`)
+
+		_, _ = sb.WriteString(`<d:displayname>`)
+		_, _ = sb.WriteString(e.escName)
+		_, _ = sb.WriteString(`</d:displayname>`)
+
+		_, _ = sb.WriteString(`</d:prop>`)
+		_, _ = sb.WriteString(`<d:status>HTTP/1.1 200 OK</d:status>`)
+		_, _ = sb.WriteString(`</d:propstat>`)
+		_, _ = sb.WriteString(`</d:response>`)
+	}
+
+	// Close root element
+	_, _ = sb.WriteString(`</d:multistatus>`)
+
+	// Set headers
+	w.Header().Set("Content-Type", "application/xml; charset=utf-8")
+	w.Header().Set("Vary", "Accept-Encoding")
+
+	// Set status code and write response
+	w.WriteHeader(http.StatusMultiStatus) // 207 MultiStatus
+	_, _ = w.Write(sb.Bytes())
+}
+
+// Basic XML escaping function
+func xmlEscape(s string) string {
+	var b strings.Builder
+	b.Grow(len(s))
+	for _, r := range s {
+		switch r {
+		case '&':
+			b.WriteString("&amp;")
+		case '<':
+			b.WriteString("&lt;")
+		case '>':
+			b.WriteString("&gt;")
+		case '"':
+			b.WriteString("&quot;")
+		case '\'':
+			b.WriteString("&apos;")
+		default:
+			b.WriteRune(r)
+		}
+	}
+	return b.String()
+}

pkg/webdav/templates.go

@@ -1,131 +0,0 @@
-package webdav
-
-const rootTemplate = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>WebDAV Shares</title>
-    <style>
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        h1 {
-            color: #2c3e50;
-        }
-        ul {
-            list-style: none;
-            padding: 0;
-        }
-        li {
-            margin: 10px 0;
-        }
-        a {
-            color: #3498db;
-            text-decoration: none;
-            padding: 10px;
-            display: block;
-            border: 1px solid #eee;
-            border-radius: 4px;
-        }
-        a:hover {
-            background-color: #f7f9fa;
-        }
-    </style>
-</head>
-<body>
-    <h1>Available WebDAV Shares</h1>
-    <ul>
-        {{range .Handlers}}
-            <li><a href="{{$.Prefix}}{{.RootPath}}">{{$.Prefix}}{{.RootPath}}</a></li>
-        {{end}}
-    </ul>
-</body>
-</html>
-`
-
-const directoryTemplate = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Index of {{.Path}}</title>
-    <style>
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-            margin: 0 auto;
-            padding: 20px;
-        }
-        h1 {
-            color: #2c3e50;
-        }
-        ul {
-            list-style: none;
-            padding: 0;
-        }
-        li {
-            margin: 10px 0;
-        }
-        a {
-            color: #3498db;
-            text-decoration: none;
-            padding: 10px;
-            display: block;
-            border: 1px solid #eee;
-            border-radius: 4px;
-            position: relative;
-            padding-left: 50px; /* Make room for the number */
-        }
-        a:hover {
-            background-color: #f7f9fa;
-        }
-        .file-info {
-            color: #666;
-            font-size: 0.9em;
-            float: right;
-        }
-        .parent-dir {
-            background-color: #f8f9fa;
-        }
-        .file-number {
-            position: absolute;
-            left: 10px;
-            top: 10px;
-            width: 30px;
-            color: #777;
-            font-weight: bold;
-            text-align: right;
-        }
-        .file-name {
-            display: inline-block;
-            max-width: 70%;
-            overflow: hidden;
-            text-overflow: ellipsis;
-            white-space: nowrap;
-        }
-    </style>
-</head>
-<body>
-    <h1>Index of {{.Path}}</h1>
-    <ul>
-        {{if .ShowParent}}
-            <li><a href="{{urlpath .ParentPath}}" class="parent-dir"><span class="file-number"></span>Parent Directory</a></li>
-        {{end}}
-        {{range $index, $file := .Children}}
-            <li>
-                <a href="{{urlpath (printf "%s/%s" $.Path $file.Name)}}">
-                    <span class="file-number">{{add $index 1}}.</span>
-                    <span class="file-name">{{$file.Name}}{{if $file.IsDir}}/{{end}}</span>
-                    <span class="file-info">
-                        {{if not $file.IsDir}}
-                            {{formatSize $file.Size}}
-                        {{end}}
-                        {{$file.ModTime.Format "2006-01-02 15:04:05"}}
-                    </span>
-                </a>
-            </li>
-        {{end}}
-    </ul>
-</body>
-</html>
-`