Merge branch 'beta'

- Few cleanup

.dockerignore

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

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -0,0 +1,76 @@
+name: Bug Report
+description: 'Report a new bug'
+labels: ['Type: Bug', 'Status: Needs Triage']
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an open or closed issue already exists for the bug you encountered. If a bug exists and is closed note that it may only be fixed in an unstable branch.
+      options:
+        - label: I have searched the existing open and closed issues
+          required: true
+  - type: textarea
+    attributes:
+      label: Current Behavior
+      description: A concise description of what you're experiencing.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Expected Behavior
+      description: A concise description of what you expected to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Steps To Reproduce
+      description: Steps to reproduce the behavior.
+      placeholder: |
+        1. In this environment...
+        2. With this config...
+        3. Run '...'
+        4. See error...
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Environment
+      description: |
+        examples:
+          - **OS**: Ubuntu 20.04
+          - **Version**: v1.0.0
+          - **Docker Install**: Yes
+          - **Browser**: Firefox 90 (If UI related)
+      value: |
+        - OS: 
+        - Version: 
+        - Docker Install: 
+        - Browser:
+      render: markdown
+    validations:
+      required: true
+  - type: dropdown
+    attributes:
+      label: What branch are you running?
+      options:
+        - Main/Latest
+        - Beta
+        - Experimental
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Trace Logs? **Not Optional**
+      description: |
+        Trace Logs 
+        - are **required** for bug reports
+        - are not optional
+    validations:
+      required: true
+  - type: checkboxes
+    attributes:
+      label: Trace Logs have been provided as applicable
+      description: Trace logs are **generally required** and are not optional for all bug reports and contain `trace`. Info logs are invalid for bug reports and do not contain `debug` nor `trace`
+      options:
+        - label: I have read and followed the steps in the documentation link and provided the required trace logs - the logs contain `trace` - that are relevant and show this issue.
+          required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -0,0 +1,38 @@
+name: Feature Request
+description: 'Suggest an idea for Decypharr'
+labels: ['Type: Feature Request', 'Status: Needs Triage']
+body:
+  - type: checkboxes
+    attributes:
+      label: Is there an existing issue for this?
+      description: Please search to see if an open or closed issue already exists for the feature you are requesting. If a request exists and is closed note that it may only be fixed in an unstable branch.
+      options:
+        - label: I have searched the existing open and closed issues
+          required: true
+  - type: textarea
+    attributes:
+      label: Is your feature request related to a problem? Please describe
+      description: A clear and concise description of what the problem is.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the solution you'd like
+      description: A clear and concise description of what you want to happen.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe alternatives you've considered
+      description: A clear and concise description of any alternative solutions or features you've considered.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Anything else?
+      description: |
+        Links? References? Mockups? Anything that will give us more context about the feature you are encountering!
+        
+        Tip: You can attach images or log files by clicking this area to highlight it and then dragging files in.
+    validations:
+      required: true

.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,12 @@ 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"]
+
+# Base healthcheck
+HEALTHCHECK --interval=3s --retries=10 CMD ["/usr/bin/healthcheck", "--config", "/app", "--basic"]
 
 CMD ["/usr/bin/decypharr", "--config", "/app"]

README.md

@@ -1,21 +1,21 @@
-# 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.
 
 ## Features
 
-- 🔄 Mock Qbittorent API that supports the Arrs (Sonarr, Radarr, Lidarr etc)
-- 🖥️ Full-fledged UI for managing torrents
-- 🛡️ Proxy support for filtering out un-cached Debrid torrents
-- 🔌 Multiple Debrid providers support
-- 📁 WebDAV server support for each debrid provider
-- 🔧 Repair Worker for missing files
+- Mock Qbittorent API that supports the Arrs (Sonarr, Radarr, Lidarr etc)
+- Full-fledged UI for managing torrents
+- Proxy support for filtering out un-cached Debrid torrents
+- Multiple Debrid providers support
+- WebDAV server support for each debrid provider
+- Repair Worker for missing files
 
 ## Supported Debrid Providers
 
@@ -36,20 +36,15 @@ services:
     container_name: decypharr
     ports:
       - "8282:8282" # qBittorrent
-    user: "1000:1000"
     volumes:
       - /mnt/:/mnt
       - ./configs/:/app # config.json must be in this directory
-    environment:
-      - PUID=1000
-      - PGID=1000
-      - UMASK=002
     restart: unless-stopped
 ```
 
 ## 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 +62,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

@@ -7,16 +7,16 @@ import (
 	"github.com/sirrobot01/decypharr/internal/logger"
 	"github.com/sirrobot01/decypharr/pkg/qbit"
 	"github.com/sirrobot01/decypharr/pkg/server"
-	"github.com/sirrobot01/decypharr/pkg/service"
+	"github.com/sirrobot01/decypharr/pkg/store"
 	"github.com/sirrobot01/decypharr/pkg/version"
 	"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 +26,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().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, cancelSvc, 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()
+			store.Reset()
+
+			// rebuild svcCtx off the original parent
+			svcCtx, cancelSvc = context.WithCancel(ctx)
+			runtime.GC()
+
+			config.Reload()
+			store.Reset()
+			// loop will restart services automatically
+		}
+	}
+}
+
+func startServices(ctx context.Context, cancelSvc context.CancelFunc, 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 +137,7 @@ func Start(ctx context.Context) error {
 	}
 
 	safeGo(func() error {
-		return _webdav.Start(ctx)
+		return wd.Start(ctx)
 	})
 
 	safeGo(func() error {
@@ -85,29 +145,49 @@ func Start(ctx context.Context) error {
 	})
 
 	safeGo(func() error {
-		return worker.Start(ctx)
+		arr := store.Get().Arr()
+		if arr == nil {
+			return nil
+		}
+		return arr.StartSchedule(ctx)
 	})
 
-	if cfg.Repair.Enabled {
+	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")
+			repair := store.Get().Repair()
+			if repair != nil {
+				if err := repair.Start(ctx); err != nil {
+					_log.Error().Err(err).Msg("repair failed")
+				}
 			}
-			return nil // Not propagating repair errors to terminate the app
+			return nil
 		})
 	}
 
+	safeGo(func() error {
+		return store.Get().StartQueueSchedule(ctx)
+	})
+
 	go func() {
 		wg.Wait()
 		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")
+				// If the error is critical, return it to stop the main loop
+				if ctx.Err() == nil {
+					_log.Error().Msg("Stopping services due to error")
+					cancelSvc() // Cancel the service context to stop all services
+				}
+			}
+		}
+	}()
+
+	// 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,174 @@ 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
+		isBasicCheck bool
+		debug        bool
+	)
+	flag.StringVar(&configPath, "config", "/data", "path to the data folder")
+	flag.BoolVar(&isBasicCheck, "basic", false, "perform basic health check without WebDAV")
+	flag.BoolVar(&debug, "debug", false, "enable debug mode for detailed output")
+	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
+	}
+
+	if isBasicCheck {
+		status.WebDAVService = checkBaseWebdav(ctx, baseUrl, port)
+	} else {
+		// If not a basic check, check WebDAV with debrid path
+		if webdavPath != "" {
+			status.WebDAVService = checkDebridWebDAV(ctx, baseUrl, port, webdavPath)
+		} else {
+			// If no WebDAV path is set, 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 debug {
+		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 checkBaseWebdav(ctx context.Context, baseUrl, port string) bool {
+	url := fmt.Sprintf("http://localhost:%s%swebdav/", port, baseUrl)
+	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 == http.StatusMultiStatus ||
+		resp.StatusCode == http.StatusOK
+}
+
+func checkDebridWebDAV(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 == http.StatusMultiStatus ||
+		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,25 +48,25 @@ 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
 
 You can set minimum and maximum file size limits for torrents:
 ```json
-"min_file_size": 0,  // Minimum file size in bytes (0 = no minimum)
-"max_file_size": 0   // Maximum file size in bytes (0 = no maximum)
+"min_file_size": 0,
+"max_file_size": 0
 ```
 
 #### 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": [
-  ".mp4", ".mkv", ".avi", ".mov",
-  ".m4v", ".mpg", ".mpeg", ".wmv",
-  ".m4a", ".mp3", ".flac", ".wav"
+  "mp4", "mkv", "avi", "mov",
+  "m4v", "mpg", "mpeg", "wmv",
+  "m4a", "mp3", "flac", "wav"
 ]
 ```
 

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": {
@@ -23,8 +23,7 @@ Here's a minimal configuration to get started:
   },
   "repair": {
     "enabled": false,
-    "interval": "12h",
-    "run_on_start": false
+    "interval": "12h"
   },
   "use_auth": false,
   "log_level": "info"
@@ -33,7 +32,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

@@ -1,5 +1,7 @@
 # Repair Worker
 
+![Repair Worker](../images/repair.png)
+
 The Repair Worker is a powerful feature that helps maintain the health of your media library by scanning for and fixing issues with files.
 
 ## What It Does
@@ -19,7 +21,6 @@ To enable and configure the Repair Worker, add the following to your `config.jso
 "repair": {
   "enabled": true,
   "interval": "12h",
-  "run_on_start": false,
   "use_webdav": false,
   "zurg_url": "http://localhost:9999",
   "auto_process": true
@@ -30,7 +31,6 @@ 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.
 - `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,17 @@
 # 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.
+![WebDAV Server](../images/webdav.png)
+
+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 +25,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 +51,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 +68,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/downloading.md

@@ -0,0 +1,22 @@
+### Downloading with Decypharr
+
+While Decypharr provides a Qbittorent API for integration with media management applications, it also allows you to manually download torrents directly through its interface. This guide will walk you through the process of downloading torrents using Decypharr.
+
+- You can either use the Decypharr UI to add torrents manually or use its API to automate the process.
+
+## Manual Downloading
+
+![Downloading UI](../images/download.png)
+To manually download a torrent using Decypharr, follow these steps:
+1. **Access the Download Page**: Navigate to the "Download" section in the Decypharr UI.
+2. You can either upload torrent file(s) or paste magnet links directly into the input fields
+3. Select the action(defaults to Symlink)
+5. Add any additional options, such as:
+   - *Download Folder*: Specify the folder where the downloaded files will be saved.
+   - *Arr Category*: Choose the category for the download, which helps in organizing files in your media management applications.
+   - **Debrid Provider**: Choose which Debrid service to use for the download(if you have multiple)
+   - **File Size Limits**: Set minimum and maximum file size limits if needed.
+   - **Allowed File Types**: Specify which file types are allowed for download.
+
+Note:
+- If you use an arr category, your download will go into **{download_folder}/{arr}**

docs/docs/guides/index.md

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

docs/docs/guides/rclone.md

@@ -0,0 +1,152 @@
+# 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 a 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 = http://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": "rclone:5572"
+    }
+  ],
+  "qbittorrent": {
+    "download_folder": "data/media/symlinks/",
+    "refresh_interval": 10
+  }
+}
+
+```
+
+### Docker Compose Setup
+
+- Check your current user and group IDs by running `id -u` and `id -g` in your terminal. You can use these values to set the `PUID` and `PGID` environment variables in the Docker Compose file.
+- You should also set `user` to your user ID and group ID in the Docker Compose file to ensure proper file permissions.
+
+Create a `docker-compose.yml` file with the following content:
+
+```yaml
+services:
+  decypharr:
+    image: cy01/blackhole:latest
+    container_name: decypharr
+    user: "${PUID:-1000}:${PGID:-1000}"
+    volumes:
+      - /mnt/:/mnt:rslave
+      - /opt/decypharr/:/app
+    environment:
+      - UMASK=002
+      - PUID=1000 # Replace with your user ID
+      - PGID=1000 # Replace with your group ID
+    ports:
+      - "8282:8282/tcp"
+    restart: unless-stopped
+  
+  rclone:
+    image: rclone/rclone:latest
+    container_name: rclone
+    restart: unless-stopped
+    environment:
+      TZ: UTC
+    ports:
+     - 5572:5572
+    volumes:
+      - /mnt/remote/realdebrid:/data:rshared
+      - /opt/rclone/rclone.conf:/config/rclone/rclone.conf
+    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 --dir-cache-time 10s --rc --rc-addr :5572 --rc-no-auth"
+```
+
+#### Docker Notes
+
+- Ensure that the `/mnt/` directory is mounted correctly to access your media files.
+- You can check your current user and group IDs and UMASK by running `id -a` and `umask` commands in your terminal.
+- You can adjust the `PUID` and `PGID` environment variables to match your user and group IDs for proper file permissions.
+- Also adding `--uid=$YOUR_PUID --gid=$YOUR_PGID` to the `rclone mount` command can help with permissions.
+- The `UMASK` environment variable can be set to control file permissions created by Decypharr.
+
+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 = http://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,34 +21,41 @@ 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:
 
 ```yaml
-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
-    user: "1000:1000"
+      - "8282:8282"
     volumes:
-      - /mnt/:/mnt
-      - ./configs/:/app # config.json must be in this directory
-    environment:
-      - PUID=1000
-      - PGID=1000
-      - UMASK=002
+      - /mnt/:/mnt:rslave # Mount your media directory
+      - ./config/:/app # config.json must be in this directory
       - 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:
@@ -60,12 +67,65 @@ docker-compose up -d
 ## Binary Installation
 If you prefer not to use Docker, you can download and run the binary directly.
 
-Download the binary from the releases page
+Download your OS-specific release from the [releases page](https://github.com/sirrobot01/decypharr/releases).
 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"
+}
+```
+
+### Notes for Docker Users
+
+- Ensure that the `/mnt/` directory is mounted correctly to access your media files.
+- The `./config/` directory should contain your `config.json` file.
+- You can adjust the `PUID` and `PGID` environment variables to match your user and group IDs for proper file permissions.
+- The `UMASK` environment variable can be set to control file permissions created by Decypharr.
+
+##### Health Checks
+- Health checks are disabled by default. You can enable them by adding a `healthcheck` section in your `docker-compose.yml` file.
+- Health checks checks for availability of several parts of the application;
+    - The main web interface
+    - The qBittorrent API
+    - The WebDAV server (if enabled). You should disable health checks for the initial indexes as they can take a long time to complete.
+
+```yaml
+services:
+  decypharr:
+    ...
+    ...
+    healthcheck:
+      test: ["CMD", "/usr/bin/healthcheck", "--config", "/app/"]
+      interval: 5s
+      timeout: 10s
+      retries: 3
+```

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,42 +1,39 @@
 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
+	go.uber.org/ratelimit v0.3.1
 	golang.org/x/crypto v0.33.0
 	golang.org/x/net v0.35.0
 	golang.org/x/sync v0.12.0
-	golang.org/x/time v0.8.0
 	gopkg.in/natefinch/lumberjack.v2 v2.2.1
 )
 
 require (
 	github.com/anacrolix/missinggo v1.3.0 // indirect
 	github.com/anacrolix/missinggo/v2 v2.7.3 // indirect
+	github.com/benbjohnson/clock v1.3.0 // indirect
 	github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
 	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,8 @@ 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/clock v1.3.0 h1:ip6w0uFQkncKQ979AypyG0ER7mqUSBdKLOgAle/AT8A=
+github.com/benbjohnson/clock v1.3.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
 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 +61,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 +72,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 +126,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 +185,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 +200,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 +213,17 @@ 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/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
+go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/ratelimit v0.3.1 h1:K4qVE+byfv/B3tC+4nYWP7v/6SimcO7HzHekoMNBma0=
+go.uber.org/ratelimit v0.3.1/go.mod h1:6euWsTB6U/Nb3X++xEUXA8ciPJvr19Q/0h1+oDcJhRk=
 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,10 +272,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=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/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,81 @@ 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
+	RepairRateLimit   string   `json:"repair_rate_limit,omitempty"`
+	DownloadRateLimit string   `json:"download_rate_limit,omitempty"`
+	Proxy             string   `json:"proxy,omitempty"`
+	UnpackRar         bool     `json:"unpack_rar,omitempty"`
+	AddSamples        bool     `json:"add_samples,omitempty"`
+	MinimumFreeSlot   int      `json:"minimum_free_slot,omitempty"` // Minimum active pots to use this debrid
 
-	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"`
+	SelectedDebrid   string `json:"selected_debrid,omitempty"`
+	Source           string `json:"source,omitempty"` // The source of the arr, e.g. "auto", "config", "". Auto means it was automatically detected from the arr
 }
 
 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"`
+	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"`
-	Auth           *Auth       `json:"-"`
-	DiscordWebhook string      `json:"discord_webhook_url"`
+	// 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,omitempty"`
+	RemoveStalledAfter string      `json:"remove_stalled_after,omitzero"`
 }
 
 func (c *Config) JsonFile() string {
@@ -104,6 +103,10 @@ func (c *Config) AuthFile() string {
 	return filepath.Join(c.Path, "auth.json")
 }
 
+func (c *Config) TorrentsFile() string {
+	return filepath.Join(c.Path, "torrents.json")
+}
+
 func (c *Config) loadConfig() error {
 	// Load the config file
 	if configPath == "" {
@@ -112,29 +115,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 +138,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 +209,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 +221,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 +266,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,10 +278,18 @@ 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)
+	var downloadKeys []string
+
+	if len(d.DownloadAPIKeys) > 0 {
+		downloadKeys = d.DownloadAPIKeys
+	} else {
+		// If no download API keys are specified, use the main API key
+		downloadKeys = []string{d.APIKey}
 	}
+	d.DownloadAPIKeys = downloadKeys
 
 	if !d.UseWebDav {
 		return d
@@ -304,7 +302,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 +310,92 @@ 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{}
+}
+
+func DefaultFreeSlot() int {
+	return 10
+}

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/request.go

@@ -2,22 +2,20 @@ package request
 
 import (
 	"bytes"
-	"compress/gzip"
 	"context"
 	"crypto/tls"
+	"encoding/json"
+	"errors"
 	"fmt"
-	"github.com/goccy/go-json"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/logger"
+	"go.uber.org/ratelimit"
 	"golang.org/x/net/proxy"
-	"golang.org/x/time/rate"
 	"io"
-	"math"
 	"math/rand"
 	"net"
 	"net/http"
 	"net/url"
-	"regexp"
 	"strconv"
 	"strings"
 	"sync"
@@ -53,7 +51,7 @@ type ClientOption func(*Client)
 // Client represents an HTTP client with additional capabilities
 type Client struct {
 	client          *http.Client
-	rateLimiter     *rate.Limiter
+	rateLimiter     ratelimit.Limiter
 	headers         map[string]string
 	headersMu       sync.RWMutex
 	maxRetries      int
@@ -62,23 +60,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
@@ -102,7 +83,7 @@ func WithRedirectPolicy(policy func(req *http.Request, via []*http.Request) erro
 }
 
 // WithRateLimiter sets a rate limiter
-func WithRateLimiter(rl *rate.Limiter) ClientOption {
+func WithRateLimiter(rl ratelimit.Limiter) ClientOption {
 	return func(c *Client) {
 		c.rateLimiter = rl
 	}
@@ -138,6 +119,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{}{}
 		}
@@ -153,9 +135,11 @@ func WithProxy(proxyURL string) ClientOption {
 // doRequest performs a single HTTP request with rate limiting
 func (c *Client) doRequest(req *http.Request) (*http.Response, error) {
 	if c.rateLimiter != nil {
-		err := c.rateLimiter.Wait(req.Context())
-		if err != nil {
-			return nil, fmt.Errorf("rate limiter wait: %w", err)
+		select {
+		case <-req.Context().Done():
+			return nil, req.Context().Err()
+		default:
+			c.rateLimiter.Take()
 		}
 	}
 
@@ -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
@@ -412,30 +340,36 @@ func New(options ...ClientOption) *Client {
 	return client
 }
 
-func ParseRateLimit(rateStr string) *rate.Limiter {
+func ParseRateLimit(rateStr string) ratelimit.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]
+	// Set slack size to 10%
+	slackSize := count / 10
+
+	// normalize unit
+	unit := strings.ToLower(strings.TrimSpace(parts[1]))
+	unit = strings.TrimSuffix(unit, "s")
 	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))
-		return rate.NewLimiter(rate.Limit(float64(count)), burstSize)
+	case "minute", "min":
+		return ratelimit.New(count, ratelimit.Per(time.Minute), ratelimit.WithSlack(slackSize))
+	case "second", "sec":
+		return ratelimit.New(count, ratelimit.Per(time.Second), ratelimit.WithSlack(slackSize))
+	case "hour", "hr":
+		return ratelimit.New(count, ratelimit.Per(time.Hour), ratelimit.WithSlack(slackSize))
+	case "day", "d":
+		return ratelimit.New(count, ratelimit.Per(24*time.Hour), ratelimit.WithSlack(slackSize))
 	default:
 		return nil
 	}
@@ -450,27 +384,36 @@ 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)
-	if err != nil {
-		return nil
-	}
-	err = gz.Close()
-	if err != nil {
-		return nil
-	}
-	return b.Bytes()
-}
-
 func Default() *Client {
 	once.Do(func() {
 		instance = New()
 	})
 	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()
+	}
+
+	// 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/error.go

@@ -1,4 +1,6 @@
-package request
+package utils
+
+import "errors"
 
 type HTTPError struct {
 	StatusCode int
@@ -27,3 +29,19 @@ var ErrLinkBroken = &HTTPError{
 	Message:    "File is unavailable",
 	Code:       "file_unavailable",
 }
+
+var TorrentNotFoundError = &HTTPError{
+	StatusCode: 404,
+	Message:    "Torrent not found",
+	Code:       "torrent_not_found",
+}
+
+var TooManyActiveDownloadsError = &HTTPError{
+	StatusCode: 509,
+	Message:    "Too many active downloads",
+	Code:       "too_many_active_downloads",
+}
+
+func IsTooManyActiveDownloadsError(err error) bool {
+	return errors.As(err, &TooManyActiveDownloadsError)
+}

internal/utils/file.go

@@ -1,2 +1,86 @@
 package utils
 
+import (
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"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
+}
+
+func PreCacheFile(filePaths []string) error {
+	if len(filePaths) == 0 {
+		return fmt.Errorf("no file paths provided")
+	}
+
+	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 := readSmallChunks(file, 0, 256*1024, 16*1024); err != nil {
+				return err
+			}
+			if err := readSmallChunks(file, 1024*1024, 64*1024, 16*1024); err != nil {
+				return err
+			}
+			return nil
+		}(filePath)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func readSmallChunks(file *os.File, startPos int64, totalToRead int, chunkSize int) error {
+	_, err := file.Seek(startPos, 0)
+	if err != nil {
+		return err
+	}
+
+	buf := make([]byte, chunkSize)
+	bytesRemaining := totalToRead
+
+	for bytesRemaining > 0 {
+		toRead := chunkSize
+		if bytesRemaining < chunkSize {
+			toRead = bytesRemaining
+		}
+
+		n, err := file.Read(buf[:toRead])
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+
+		bytesRemaining -= n
+	}
+	return nil
+}

internal/utils/magnet.go

@@ -20,12 +20,16 @@ import (
 	"time"
 )
 
+var (
+	hexRegex = regexp.MustCompile("^[0-9a-fA-F]{40}$")
+)
+
 type Magnet struct {
-	Name     string
-	InfoHash string
-	Size     int64
-	Link     string
-	File     []byte
+	Name     string `json:"name"`
+	InfoHash string `json:"infoHash"`
+	Size     int64  `json:"size"`
+	Link     string `json:"link"`
+	File     []byte `json:"-"`
 }
 
 func (m *Magnet) IsTorrent() bool {
@@ -79,7 +83,6 @@ func GetMagnetFromBytes(torrentData []byte) (*Magnet, error) {
 	if err != nil {
 		return nil, err
 	}
-	log.Println("InfoHash: ", infoHash)
 	magnet := &Magnet{
 		InfoHash: infoHash,
 		Name:     info.Name,
@@ -188,7 +191,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,22 +40,19 @@ 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)
-	if loc != nil {
+	if loc := mediaRegex.FindStringIndex(value); loc != nil {
 		return value[:loc[0]]
-	} else {
-		return value
 	}
+	return value
 }
 
 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,13 +2,16 @@ package arr
 
 import (
 	"bytes"
+	"context"
+	"crypto/tls"
+	"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"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -17,6 +20,13 @@ import (
 // Type is a type of arr
 type Type string
 
+var sharedClient = &http.Client{
+	Transport: &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	},
+	Timeout: 60 * time.Second,
+}
+
 const (
 	Sonarr  Type = "sonarr"
 	Radarr  Type = "radarr"
@@ -32,10 +42,11 @@ type Arr struct {
 	Cleanup          bool   `json:"cleanup"`
 	SkipRepair       bool   `json:"skip_repair"`
 	DownloadUncached *bool  `json:"download_uncached"`
-	client           *request.Client
+	SelectedDebrid   string `json:"selected_debrid,omitempty"` // The debrid service selected for this arr
+	Source           string `json:"source,omitempty"`          // The source of the arr, e.g. "auto", "manual". Auto means it was automatically detected from the arr
 }
 
-func New(name, host, token string, cleanup, skipRepair bool, downloadUncached *bool) *Arr {
+func New(name, host, token string, cleanup, skipRepair bool, downloadUncached *bool, selectedDebrid, source string) *Arr {
 	return &Arr{
 		Name:             name,
 		Host:             host,
@@ -44,7 +55,8 @@ func New(name, host, token string, cleanup, skipRepair bool, downloadUncached *b
 		Cleanup:          cleanup,
 		SkipRepair:       skipRepair,
 		DownloadUncached: downloadUncached,
-		client:           request.New(),
+		SelectedDebrid:   selectedDebrid,
+		Source:           source,
 	}
 }
 
@@ -71,14 +83,11 @@ func (a *Arr) Request(method, endpoint string, payload interface{}) (*http.Respo
 	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("X-Api-Key", a.Token)
-	if a.client == nil {
-		a.client = request.New()
-	}
 
 	var resp *http.Response
 
 	for attempts := 0; attempts < 5; attempts++ {
-		resp, err = a.client.Do(req)
+		resp, err = sharedClient.Do(req)
 		if err != nil {
 			return nil, err
 		}
@@ -100,7 +109,7 @@ func (a *Arr) Request(method, endpoint string, payload interface{}) (*http.Respo
 
 func (a *Arr) Validate() error {
 	if a.Token == "" || a.Host == "" {
-		return nil
+		return fmt.Errorf("arr not configured: %s", a.Name)
 	}
 	resp, err := a.Request("GET", "/api/v3/health", nil)
 	if err != nil {
@@ -113,8 +122,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 (s *Storage) Cleanup() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Arrs = make(map[string]*Arr)
 }
 
 func InferType(host, name string) Type {
@@ -135,55 +151,80 @@ func InferType(host, name string) Type {
 func NewStorage() *Storage {
 	arrs := make(map[string]*Arr)
 	for _, a := range config.Get().Arrs {
+		if a.Host == "" || a.Token == "" || a.Name == "" {
+			continue // Skip if host or token is not set
+		}
 		name := a.Name
-		arrs[name] = New(name, a.Host, a.Token, a.Cleanup, a.SkipRepair, a.DownloadUncached)
+		arrs[name] = New(name, a.Host, a.Token, a.Cleanup, a.SkipRepair, a.DownloadUncached, a.SelectedDebrid, a.Source)
 	}
 	return &Storage{
-		Arrs: arrs,
+		Arrs:   arrs,
+		logger: logger.New("arr"),
 	}
 }
 
-func (as *Storage) AddOrUpdate(arr *Arr) {
-	as.mu.Lock()
-	defer as.mu.Unlock()
-	if arr.Name == "" {
+func (s *Storage) AddOrUpdate(arr *Arr) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if arr.Host == "" || arr.Token == "" || arr.Name == "" {
 		return
 	}
-	as.Arrs[arr.Name] = arr
+	s.Arrs[arr.Name] = arr
 }
 
-func (as *Storage) Get(name string) *Arr {
-	as.mu.RLock()
-	defer as.mu.RUnlock()
-	return as.Arrs[name]
+func (s *Storage) Get(name string) *Arr {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.Arrs[name]
 }
 
-func (as *Storage) GetAll() []*Arr {
-	as.mu.RLock()
-	defer as.mu.RUnlock()
-	arrs := make([]*Arr, 0, len(as.Arrs))
-	for _, arr := range as.Arrs {
-		if arr.Host != "" && arr.Token != "" {
-			arrs = append(arrs, arr)
-		}
+func (s *Storage) GetAll() []*Arr {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	arrs := make([]*Arr, 0, len(s.Arrs))
+	for _, arr := range s.Arrs {
+		arrs = append(arrs, arr)
 	}
 	return arrs
 }
 
-func (a *Arr) Refresh() error {
+func (s *Storage) StartSchedule(ctx context.Context) error {
+
+	ticker := time.NewTicker(10 * time.Second)
+
+	select {
+	case <-ticker.C:
+		s.cleanupArrsQueue()
+	case <-ctx.Done():
+		ticker.Stop()
+		return nil
+	}
+	return nil
+}
+
+func (s *Storage) cleanupArrsQueue() {
+	arrs := make([]*Arr, 0)
+	for _, arr := range s.Arrs {
+		if !arr.Cleanup {
+			continue
+		}
+		arrs = append(arrs, arr)
+	}
+	if len(arrs) > 0 {
+		for _, arr := range arrs {
+			if err := arr.CleanupQueue(); err != nil {
+				s.logger.Error().Err(err).Msgf("Failed to cleanup arr %s", arr.Name)
+			}
+		}
+	}
+}
+
+func (a *Arr) Refresh() {
 	payload := struct {
 		Name string `json:"name"`
 	}{
 		Name: "RefreshMonitoredDownloads",
 	}
 
-	resp, err := a.Request(http.MethodPost, "api/v3/command", payload)
-	if err == nil && resp != nil {
-		statusOk := strconv.Itoa(resp.StatusCode)[0] == '2'
-		if statusOk {
-			return nil
-		}
-	}
-
-	return fmt.Errorf("failed to refresh: %v", err)
+	_, _ = a.Request(http.MethodPost, "api/v3/command", payload)
 }

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"
@@ -105,6 +105,7 @@ func (a *Arr) GetMedia(mediaId string) ([]Content, error) {
 				Id:           d.Id,
 				EpisodeId:    eId,
 				SeasonNumber: file.SeasonNumber,
+				Size:         file.Size,
 			})
 		}
 		if len(files) == 0 {
@@ -148,6 +149,7 @@ func GetMovies(a *Arr, tvId string) ([]Content, error) {
 			FileId: movie.MovieFile.Id,
 			Id:     movie.Id,
 			Path:   movie.MovieFile.Path,
+			Size:   movie.MovieFile.Size,
 		})
 		ct.Files = files
 		contents = append(contents, ct)
@@ -247,6 +249,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"
@@ -205,5 +205,4 @@ func (a *Arr) Import(path string, seriesId int, seasons []int) (io.ReadCloser, e
 	}
 	defer resp.Body.Close()
 	return resp.Body, nil
-
 }

pkg/arr/types.go

@@ -1,5 +1,7 @@
 package arr
 
+import "os"
+
 type Movie struct {
 	Title         string `json:"title"`
 	OriginalTitle string `json:"originalTitle"`
@@ -9,6 +11,7 @@ type Movie struct {
 		RelativePath string `json:"relativePath"`
 		Path         string `json:"path"`
 		Id           int    `json:"id"`
+		Size         int64  `json:"size"`
 	} `json:"movieFile"`
 	Id int `json:"id"`
 }
@@ -23,6 +26,14 @@ type ContentFile struct {
 	IsSymlink    bool   `json:"isSymlink"`
 	IsBroken     bool   `json:"isBroken"`
 	SeasonNumber int    `json:"seasonNumber"`
+	Processed    bool   `json:"processed"`
+	Size         int64  `json:"size"`
+}
+
+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 {
@@ -36,4 +47,5 @@ type seriesFile struct {
 	SeasonNumber int    `json:"seasonNumber"`
 	Path         string `json:"path"`
 	Id           int    `json:"id"`
+	Size         int64  `json:"size"`
 }

pkg/debrid/debrid.go

@@ -0,0 +1,241 @@
+package debrid
+
+import (
+	"context"
+	"errors"
+	"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"
+	"github.com/sirrobot01/decypharr/pkg/debrid/providers/alldebrid"
+	"github.com/sirrobot01/decypharr/pkg/debrid/providers/debrid_link"
+	"github.com/sirrobot01/decypharr/pkg/debrid/providers/realdebrid"
+	"github.com/sirrobot01/decypharr/pkg/debrid/providers/torbox"
+	"github.com/sirrobot01/decypharr/pkg/debrid/store"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"sync"
+)
+
+type Debrid struct {
+	cache  *store.Cache // Could be nil if not using WebDAV
+	client types.Client // HTTP client for making requests to the debrid service
+}
+
+func (de *Debrid) Client() types.Client {
+	return de.client
+}
+
+func (de *Debrid) Cache() *store.Cache {
+	return de.cache
+}
+
+type Storage struct {
+	debrids  map[string]*Debrid
+	mu       sync.RWMutex
+	lastUsed string
+}
+
+func NewStorage() *Storage {
+	cfg := config.Get()
+
+	_logger := logger.Default()
+
+	debrids := make(map[string]*Debrid)
+
+	for _, dc := range cfg.Debrids {
+		client, err := createDebridClient(dc)
+		if err != nil {
+			_logger.Error().Err(err).Str("Debrid", dc.Name).Msg("failed to connect to debrid client")
+			continue
+		}
+		var cache *store.Cache
+		_log := client.Logger()
+		if dc.UseWebDav {
+			cache = store.NewDebridCache(dc, client)
+			_log.Info().Msg("Debrid Service started with WebDAV")
+		} else {
+			_log.Info().Msg("Debrid Service started")
+		}
+		debrids[dc.Name] = &Debrid{
+			cache:  cache,
+			client: client,
+		}
+	}
+
+	d := &Storage{
+		debrids:  debrids,
+		lastUsed: "",
+	}
+	return d
+}
+
+func (d *Storage) Debrid(name string) *Debrid {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	if debrid, exists := d.debrids[name]; exists {
+		return debrid
+	}
+	return nil
+}
+
+func (d *Storage) Debrids() map[string]*Debrid {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	debridsCopy := make(map[string]*Debrid)
+	for name, debrid := range d.debrids {
+		if debrid != nil {
+			debridsCopy[name] = debrid
+		}
+	}
+	return debridsCopy
+}
+
+func (d *Storage) Client(name string) types.Client {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	if client, exists := d.debrids[name]; exists {
+		return client.client
+	}
+	return nil
+}
+
+func (d *Storage) Reset() {
+	d.mu.Lock()
+	d.debrids = make(map[string]*Debrid)
+	d.mu.Unlock()
+	d.lastUsed = ""
+}
+
+func (d *Storage) Clients() map[string]types.Client {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	clientsCopy := make(map[string]types.Client)
+	for name, debrid := range d.debrids {
+		if debrid != nil && debrid.client != nil {
+			clientsCopy[name] = debrid.client
+		}
+	}
+	return clientsCopy
+}
+
+func (d *Storage) Caches() map[string]*store.Cache {
+	d.mu.RLock()
+	defer d.mu.RUnlock()
+	cachesCopy := make(map[string]*store.Cache)
+	for name, debrid := range d.debrids {
+		if debrid != nil && debrid.cache != nil {
+			cachesCopy[name] = debrid.cache
+		}
+	}
+	return cachesCopy
+}
+
+func (d *Storage) FilterClients(filter func(types.Client) bool) map[string]types.Client {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+	filteredClients := make(map[string]types.Client)
+	for name, client := range d.debrids {
+		if client != nil && filter(client.client) {
+			filteredClients[name] = client.client
+		}
+	}
+	return filteredClients
+}
+
+func createDebridClient(dc config.Debrid) (types.Client, error) {
+	switch dc.Name {
+	case "realdebrid":
+		return realdebrid.New(dc)
+	case "torbox":
+		return torbox.New(dc)
+	case "debridlink":
+		return debrid_link.New(dc)
+	case "alldebrid":
+		return alldebrid.New(dc)
+	default:
+		return realdebrid.New(dc)
+	}
+}
+
+func Process(ctx context.Context, store *Storage, selectedDebrid string, magnet *utils.Magnet, a *arr.Arr, action string, overrideDownloadUncached bool) (*types.Torrent, error) {
+
+	debridTorrent := &types.Torrent{
+		InfoHash: magnet.InfoHash,
+		Magnet:   magnet,
+		Name:     magnet.Name,
+		Arr:      a,
+		Size:     magnet.Size,
+		Files:    make(map[string]types.File),
+	}
+
+	clients := store.FilterClients(func(c types.Client) bool {
+		if selectedDebrid != "" && c.Name() != selectedDebrid {
+			return false
+		}
+		return true
+	})
+
+	if len(clients) == 0 {
+		return nil, fmt.Errorf("no debrid clients available")
+	}
+
+	errs := make([]error, 0, len(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 clients {
+		_logger := db.Logger()
+		_logger.Info().
+			Str("Debrid", db.Name()).
+			Str("Arr", a.Name).
+			Str("Hash", debridTorrent.InfoHash).
+			Str("Name", debridTorrent.Name).
+			Str("Action", action).
+			Msg("Processing torrent")
+
+		if !overrideDownloadUncached && a.DownloadUncached == nil {
+			debridTorrent.DownloadUncached = db.GetDownloadUncached()
+		}
+
+		dbt, err := db.SubmitMagnet(debridTorrent)
+		if err != nil || dbt == nil || dbt.Id == "" {
+			errs = append(errs, err)
+			continue
+		}
+		dbt.Arr = a
+		_logger.Info().Str("id", dbt.Id).Msgf("Torrent: %s submitted to %s", dbt.Name, db.Name())
+		store.lastUsed = index
+
+		torrent, err := db.CheckStatus(dbt)
+		if err != nil && torrent != nil && torrent.Id != "" {
+			// Delete the torrent if it was not downloaded
+			go func(id string) {
+				_ = db.DeleteTorrent(id)
+			}(torrent.Id)
+		}
+		if err != nil {
+			errs = append(errs, err)
+			continue
+		}
+		if torrent == nil {
+			errs = append(errs, fmt.Errorf("torrent %s returned nil after checking status", dbt.Name))
+			continue
+		}
+		return torrent, nil
+	}
+	if len(errs) == 0 {
+		return nil, fmt.Errorf("failed to process torrent: no clients available")
+	}
+	joinedErrors := errors.Join(errs...)
+	return nil, fmt.Errorf("failed to process torrent: %w", joinedErrors)
+}

pkg/debrid/debrid/cache.go

@@ -1,803 +0,0 @@
-package debrid
-
-import (
-	"bufio"
-	"context"
-	"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"
-	"github.com/sirrobot01/decypharr/internal/request"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-type WebDavFolderNaming string
-
-const (
-	WebDavUseFileName          WebDavFolderNaming = "filename"
-	WebDavUseOriginalName      WebDavFolderNaming = "original"
-	WebDavUseFileNameNoExt     WebDavFolderNaming = "filename_no_ext"
-	WebDavUseOriginalNameNoExt WebDavFolderNaming = "original_no_ext"
-	WebDavUseID                WebDavFolderNaming = "id"
-)
-
-type PropfindResponse struct {
-	Data        []byte
-	GzippedData []byte
-	Ts          time.Time
-}
-
-type CachedTorrent struct {
-	*types.Torrent
-	AddedOn    time.Time `json:"added_on"`
-	IsComplete bool      `json:"is_complete"`
-}
-
-type downloadLinkCache struct {
-	Link      string
-	AccountId string
-	ExpiresAt time.Time
-}
-
-type RepairType string
-
-const (
-	RepairTypeReinsert RepairType = "reinsert"
-	RepairTypeDelete   RepairType = "delete"
-)
-
-type RepairRequest struct {
-	Type      RepairType
-	TorrentID string
-	Priority  int
-	FileName  string
-}
-
-type Cache struct {
-	dir    string
-	client types.Client
-	logger zerolog.Logger
-
-	torrents             *xsync.MapOf[string, *CachedTorrent] // key: torrent.Id, value: *CachedTorrent
-	torrentsNames        *xsync.MapOf[string, *CachedTorrent] // key: torrent.Name, value: torrent
-	listings             atomic.Value
-	downloadLinks        *xsync.MapOf[string, downloadLinkCache]
-	invalidDownloadLinks *xsync.MapOf[string, string]
-	PropfindResp         *xsync.MapOf[string, PropfindResponse]
-	folderNaming         WebDavFolderNaming
-
-	// repair
-	repairChan        chan RepairRequest
-	repairsInProgress *xsync.MapOf[string, struct{}]
-
-	// config
-	workers                      int
-	torrentRefreshInterval       time.Duration
-	downloadLinksRefreshInterval time.Duration
-	autoExpiresLinksAfter        time.Duration
-
-	// refresh mutex
-	listingRefreshMu       sync.RWMutex // for refreshing torrents
-	downloadLinksRefreshMu sync.RWMutex // for refreshing download links
-	torrentsRefreshMu      sync.RWMutex // for refreshing torrents
-
-	saveSemaphore chan struct{}
-	ctx           context.Context
-}
-
-func New(dc config.Debrid, client types.Client) *Cache {
-	cfg := config.Get()
-	torrentRefreshInterval, err := time.ParseDuration(dc.TorrentsRefreshInterval)
-	if err != nil {
-		torrentRefreshInterval = time.Second * 15
-	}
-	downloadLinksRefreshInterval, err := time.ParseDuration(dc.DownloadLinksRefreshInterval)
-	if err != nil {
-		downloadLinksRefreshInterval = time.Minute * 40
-	}
-	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
-	if err != nil {
-		autoExpiresLinksAfter = time.Hour * 24
-	}
-	workers := runtime.NumCPU() * 50
-	if dc.Workers > 0 {
-		workers = dc.Workers
-	}
-	return &Cache{
-		dir:                          filepath.Join(cfg.Path, "cache", dc.Name), // path to save cache files
-		torrents:                     xsync.NewMapOf[string, *CachedTorrent](),
-		torrentsNames:                xsync.NewMapOf[string, *CachedTorrent](),
-		invalidDownloadLinks:         xsync.NewMapOf[string, string](),
-		client:                       client,
-		logger:                       logger.New(fmt.Sprintf("%s-webdav", client.GetName())),
-		workers:                      workers,
-		downloadLinks:                xsync.NewMapOf[string, downloadLinkCache](),
-		torrentRefreshInterval:       torrentRefreshInterval,
-		downloadLinksRefreshInterval: downloadLinksRefreshInterval,
-		PropfindResp:                 xsync.NewMapOf[string, PropfindResponse](),
-		folderNaming:                 WebDavFolderNaming(dc.FolderNaming),
-		autoExpiresLinksAfter:        autoExpiresLinksAfter,
-		repairsInProgress:            xsync.NewMapOf[string, struct{}](),
-		saveSemaphore:                make(chan struct{}, 50),
-		ctx:                          context.Background(),
-	}
-}
-
-func (c *Cache) Start(ctx context.Context) error {
-	if err := os.MkdirAll(c.dir, 0755); err != nil {
-		return fmt.Errorf("failed to create cache directory: %w", err)
-	}
-	c.ctx = ctx
-
-	if err := c.Sync(); err != nil {
-		return fmt.Errorf("failed to sync cache: %w", err)
-	}
-
-	// initial download links
-	go func() {
-		c.refreshDownloadLinks()
-	}()
-
-	go func() {
-		err := c.Refresh()
-		if err != nil {
-			c.logger.Error().Err(err).Msg("Failed to start cache refresh worker")
-		}
-	}()
-
-	c.repairChan = make(chan RepairRequest, 100)
-	go c.repairWorker()
-
-	return nil
-}
-
-func (c *Cache) load() (map[string]*CachedTorrent, error) {
-	torrents := make(map[string]*CachedTorrent)
-	var results sync.Map
-
-	if err := os.MkdirAll(c.dir, 0755); err != nil {
-		return torrents, fmt.Errorf("failed to create cache directory: %w", err)
-	}
-
-	files, err := os.ReadDir(c.dir)
-	if err != nil {
-		return torrents, fmt.Errorf("failed to read cache directory: %w", err)
-	}
-
-	// Get only json files
-	var jsonFiles []os.DirEntry
-	for _, file := range files {
-		if !file.IsDir() && filepath.Ext(file.Name()) == ".json" {
-			jsonFiles = append(jsonFiles, file)
-		}
-	}
-
-	if len(jsonFiles) == 0 {
-		return torrents, nil
-	}
-
-	// Create channels with appropriate buffering
-	workChan := make(chan os.DirEntry, min(c.workers, len(jsonFiles)))
-
-	// Create a wait group for workers
-	var wg sync.WaitGroup
-
-	// Start workers
-	for i := 0; i < c.workers; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			now := time.Now()
-
-			for {
-				file, ok := <-workChan
-				if !ok {
-					return // Channel closed, exit goroutine
-				}
-
-				fileName := file.Name()
-				filePath := filepath.Join(c.dir, fileName)
-				data, err := os.ReadFile(filePath)
-				if err != nil {
-					c.logger.Debug().Err(err).Msgf("Failed to read file: %s", filePath)
-					continue
-				}
-
-				var ct CachedTorrent
-				if err := json.Unmarshal(data, &ct); err != nil {
-					c.logger.Debug().Err(err).Msgf("Failed to unmarshal file: %s", filePath)
-					continue
-				}
-
-				isComplete := true
-				if len(ct.Files) != 0 {
-					// Check if all files are valid, if not, delete the file.json and remove from cache.
-					for _, f := range ct.Files {
-						if f.Link == "" {
-							isComplete = false
-							break
-						}
-					}
-
-					if isComplete {
-						addedOn, err := time.Parse(time.RFC3339, ct.Added)
-						if err != nil {
-							addedOn = now
-						}
-						ct.AddedOn = addedOn
-						ct.IsComplete = true
-						results.Store(ct.Id, &ct)
-					}
-				}
-			}
-		}()
-	}
-
-	// Feed work to workers
-	for _, file := range jsonFiles {
-		workChan <- file
-	}
-
-	// Signal workers that no more work is coming
-	close(workChan)
-
-	// Wait for all workers to complete
-	wg.Wait()
-
-	// Convert sync.Map to regular map
-	results.Range(func(key, value interface{}) bool {
-		id, _ := key.(string)
-		torrent, _ := value.(*CachedTorrent)
-		torrents[id] = torrent
-		return true
-	})
-
-	return torrents, nil
-}
-
-func (c *Cache) Sync() error {
-	defer c.logger.Info().Msg("WebDav server sync complete")
-	cachedTorrents, err := c.load()
-	if err != nil {
-		c.logger.Debug().Err(err).Msg("Failed to load cache")
-	}
-
-	torrents, err := c.client.GetTorrents()
-	if err != nil {
-		return fmt.Errorf("failed to sync torrents: %v", err)
-	}
-
-	c.logger.Info().Msgf("Got %d torrents from %s", len(torrents), c.client.GetName())
-
-	newTorrents := make([]*types.Torrent, 0)
-	idStore := make(map[string]struct{}, len(torrents))
-	for _, t := range torrents {
-		idStore[t.Id] = struct{}{}
-		if _, ok := cachedTorrents[t.Id]; !ok {
-			newTorrents = append(newTorrents, t)
-		}
-	}
-
-	// Check for deleted torrents
-	deletedTorrents := make([]string, 0)
-	for _, t := range cachedTorrents {
-		if _, ok := idStore[t.Id]; !ok {
-			deletedTorrents = append(deletedTorrents, t.Id)
-		}
-	}
-
-	if len(deletedTorrents) > 0 {
-		c.logger.Info().Msgf("Found %d deleted torrents", len(deletedTorrents))
-		for _, id := range deletedTorrents {
-			if _, ok := cachedTorrents[id]; ok {
-				delete(cachedTorrents, id)
-				c.removeFromDB(id)
-			}
-		}
-	}
-
-	// Write these torrents to the cache
-	c.setTorrents(cachedTorrents)
-	c.logger.Info().Msgf("Loaded %d torrents from cache", len(cachedTorrents))
-
-	if len(newTorrents) > 0 {
-		c.logger.Info().Msgf("Found %d new torrents", len(newTorrents))
-		if err := c.sync(newTorrents); err != nil {
-			return fmt.Errorf("failed to sync torrents: %v", err)
-		}
-	}
-
-	return nil
-}
-
-func (c *Cache) sync(torrents []*types.Torrent) error {
-
-	// Create channels with appropriate buffering
-	workChan := make(chan *types.Torrent, min(c.workers, len(torrents)))
-
-	// Use an atomic counter for progress tracking
-	var processed int64
-	var errorCount int64
-
-	// Create a wait group for workers
-	var wg sync.WaitGroup
-
-	// Start workers
-	for i := 0; i < c.workers; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for {
-				select {
-				case t, ok := <-workChan:
-					if !ok {
-						return // Channel closed, exit goroutine
-					}
-
-					if err := c.ProcessTorrent(t, false); err != nil {
-						c.logger.Error().Err(err).Str("torrent", t.Name).Msg("sync error")
-						atomic.AddInt64(&errorCount, 1)
-					}
-
-					count := atomic.AddInt64(&processed, 1)
-					if count%1000 == 0 {
-						c.refreshListings()
-						c.logger.Info().Msgf("Progress: %d/%d torrents processed", count, len(torrents))
-					}
-
-				case <-c.ctx.Done():
-					return // Context cancelled, exit goroutine
-				}
-			}
-		}()
-	}
-
-	// Feed work to workers
-	for _, t := range torrents {
-		select {
-		case workChan <- t:
-			// Work sent successfully
-		case <-c.ctx.Done():
-			break // Context cancelled
-		}
-	}
-
-	// Signal workers that no more work is coming
-	close(workChan)
-
-	// Wait for all workers to complete
-	wg.Wait()
-
-	c.refreshListings()
-	c.logger.Info().Msgf("Sync complete: %d torrents processed, %d errors", len(torrents), errorCount)
-	return nil
-}
-
-func (c *Cache) GetTorrentFolder(torrent *types.Torrent) string {
-	switch c.folderNaming {
-	case WebDavUseFileName:
-		return torrent.Filename
-	case WebDavUseOriginalName:
-		return torrent.OriginalFilename
-	case WebDavUseFileNameNoExt:
-		return utils.RemoveExtension(torrent.Filename)
-	case WebDavUseOriginalNameNoExt:
-		return utils.RemoveExtension(torrent.OriginalFilename)
-	case WebDavUseID:
-		return torrent.Id
-	default:
-		return torrent.Filename
-	}
-}
-
-func (c *Cache) setTorrent(t *CachedTorrent) {
-	c.torrents.Store(t.Id, t)
-
-	c.torrentsNames.Store(c.GetTorrentFolder(t.Torrent), t)
-
-	c.SaveTorrent(t)
-}
-
-func (c *Cache) setTorrents(torrents map[string]*CachedTorrent) {
-	for _, t := range torrents {
-		c.torrents.Store(t.Id, t)
-		c.torrentsNames.Store(c.GetTorrentFolder(t.Torrent), t)
-	}
-
-	c.refreshListings()
-
-	c.SaveTorrents()
-}
-
-func (c *Cache) GetListing() []os.FileInfo {
-	if v, ok := c.listings.Load().([]os.FileInfo); ok {
-		return v
-	}
-	return nil
-}
-
-func (c *Cache) Close() error {
-	return nil
-}
-
-func (c *Cache) GetTorrents() map[string]*CachedTorrent {
-	torrents := make(map[string]*CachedTorrent)
-	c.torrents.Range(func(key string, value *CachedTorrent) bool {
-		torrents[key] = value
-		return true
-	})
-	return torrents
-}
-
-func (c *Cache) GetTorrent(id string) *CachedTorrent {
-	if t, ok := c.torrents.Load(id); ok {
-		return t
-	}
-	return nil
-}
-
-func (c *Cache) GetTorrentByName(name string) *CachedTorrent {
-	if t, ok := c.torrentsNames.Load(name); ok {
-		return t
-	}
-	return nil
-}
-
-func (c *Cache) SaveTorrents() {
-	c.torrents.Range(func(key string, value *CachedTorrent) bool {
-		c.SaveTorrent(value)
-		return true
-	})
-}
-
-func (c *Cache) SaveTorrent(ct *CachedTorrent) {
-	marshaled, err := json.MarshalIndent(ct, "", "  ")
-	if err != nil {
-		c.logger.Debug().Err(err).Msgf("Failed to marshal torrent: %s", ct.Id)
-		return
-	}
-
-	// Store just the essential info needed for the file operation
-	saveInfo := struct {
-		id       string
-		jsonData []byte
-	}{
-		id:       ct.Torrent.Id,
-		jsonData: marshaled,
-	}
-
-	// Try to acquire semaphore without blocking
-	select {
-	case c.saveSemaphore <- struct{}{}:
-		go func() {
-			defer func() { <-c.saveSemaphore }()
-			c.saveTorrent(saveInfo.id, saveInfo.jsonData)
-		}()
-	default:
-		c.saveTorrent(saveInfo.id, saveInfo.jsonData)
-	}
-}
-
-func (c *Cache) saveTorrent(id string, data []byte) {
-
-	fileName := id + ".json"
-	filePath := filepath.Join(c.dir, fileName)
-
-	// Use a unique temporary filename for concurrent safety
-	tmpFile := filePath + ".tmp." + strconv.FormatInt(time.Now().UnixNano(), 10)
-
-	f, err := os.Create(tmpFile)
-	if err != nil {
-		c.logger.Debug().Err(err).Msgf("Failed to create file: %s", tmpFile)
-		return
-	}
-
-	// Track if we've closed the file
-	fileClosed := false
-	defer func() {
-		// Only close if not already closed
-		if !fileClosed {
-			_ = f.Close()
-		}
-		// Clean up the temp file if it still exists and rename failed
-		_ = os.Remove(tmpFile)
-	}()
-
-	w := bufio.NewWriter(f)
-	if _, err := w.Write(data); err != nil {
-		c.logger.Debug().Err(err).Msgf("Failed to write data: %s", tmpFile)
-		return
-	}
-
-	if err := w.Flush(); err != nil {
-		c.logger.Debug().Err(err).Msgf("Failed to flush data: %s", tmpFile)
-		return
-	}
-
-	// Close the file before renaming
-	_ = f.Close()
-	fileClosed = true
-
-	if err := os.Rename(tmpFile, filePath); err != nil {
-		c.logger.Debug().Err(err).Msgf("Failed to rename file: %s", tmpFile)
-		return
-	}
-}
-
-func (c *Cache) ProcessTorrent(t *types.Torrent, refreshRclone bool) error {
-
-	isComplete := func(files map[string]types.File) bool {
-		_complete := len(files) > 0
-		for _, file := range files {
-			if file.Link == "" {
-				_complete = false
-				break
-			}
-		}
-		return _complete
-	}
-
-	if !isComplete(t.Files) {
-		if err := c.client.UpdateTorrent(t); err != nil {
-			return fmt.Errorf("failed to update torrent: %w", err)
-		}
-	}
-
-	if !isComplete(t.Files) {
-		c.logger.Debug().Msgf("Torrent %s is still not complete. Triggering a reinsert(disabled)", t.Id)
-		//ct, err := c.reInsertTorrent(t)
-		//if err != nil {
-		//	c.logger.Debug().Err(err).Msgf("Failed to reinsert torrent %s", t.Id)
-		//	return err
-		//}
-		//c.logger.Debug().Msgf("Reinserted torrent %s", ct.Id)
-
-	} else {
-		addedOn, err := time.Parse(time.RFC3339, t.Added)
-		if err != nil {
-			addedOn = time.Now()
-		}
-		ct := &CachedTorrent{
-			Torrent:    t,
-			IsComplete: len(t.Files) > 0,
-			AddedOn:    addedOn,
-		}
-		c.setTorrent(ct)
-	}
-
-	if refreshRclone {
-		c.refreshListings()
-	}
-	return nil
-}
-
-func (c *Cache) GetDownloadLink(torrentId, filename, fileLink string) string {
-
-	// Check link cache
-	if dl := c.checkDownloadLink(fileLink); dl != "" {
-		return dl
-	}
-
-	ct := c.GetTorrent(torrentId)
-	if ct == nil {
-		return ""
-	}
-	file := ct.Files[filename]
-
-	if file.Link == "" {
-		// file link is empty, refresh the torrent to get restricted links
-		ct = c.refreshTorrent(ct) // Refresh the torrent from the debrid
-		if ct == nil {
-			return ""
-		} else {
-			file = ct.Files[filename]
-		}
-	}
-
-	// If file.Link is still empty, return
-	if file.Link == "" {
-		c.logger.Debug().Msgf("File link is empty for %s. Release is probably nerfed", filename)
-		// Try to reinsert the torrent?
-		ct, err := c.reInsertTorrent(ct.Torrent)
-		if err != nil {
-			c.logger.Debug().Err(err).Msgf("Failed to reinsert torrent %s", ct.Name)
-			return ""
-		}
-		file = ct.Files[filename]
-		c.logger.Debug().Msgf("Reinserted torrent %s", ct.Name)
-	}
-
-	c.logger.Trace().Msgf("Getting download link for %s", filename)
-	downloadLink, accountId, err := c.client.GetDownloadLink(ct.Torrent, &file)
-	if err != nil {
-		if errors.Is(err, request.HosterUnavailableError) {
-			c.logger.Debug().Err(err).Msgf("Hoster is unavailable. Triggering repair for %s", ct.Name)
-			ct, err := c.reInsertTorrent(ct.Torrent)
-			if err != nil {
-				c.logger.Debug().Err(err).Msgf("Failed to reinsert torrent %s", ct.Name)
-				return ""
-			}
-			c.logger.Debug().Msgf("Reinserted torrent %s", ct.Name)
-			file = ct.Files[filename]
-			// Retry getting the download link
-			downloadLink, accountId, err = c.client.GetDownloadLink(ct.Torrent, &file)
-			if err != nil {
-				c.logger.Debug().Err(err).Msgf("Failed to get download link for %s", file.Link)
-				return ""
-			}
-			if downloadLink == "" {
-				c.logger.Debug().Msgf("Download link is empty for %s", file.Link)
-				return ""
-			}
-			file.DownloadLink = downloadLink
-			file.Generated = time.Now()
-			file.AccountId = accountId
-			ct.Files[filename] = file
-			go func() {
-				c.updateDownloadLink(file.Link, downloadLink, accountId)
-				c.setTorrent(ct)
-			}()
-			return file.DownloadLink
-		} else if errors.Is(err, request.TrafficExceededError) {
-			// This is likely a fair usage limit error
-		} else {
-			c.logger.Debug().Err(err).Msgf("Failed to get download link for %s", file.Link)
-			return ""
-		}
-	}
-	file.DownloadLink = downloadLink
-	file.Generated = time.Now()
-	file.AccountId = accountId
-	ct.Files[filename] = file
-
-	go func() {
-		c.updateDownloadLink(file.Link, downloadLink, file.AccountId)
-		c.setTorrent(ct)
-	}()
-	return file.DownloadLink
-}
-
-func (c *Cache) GenerateDownloadLinks(t *CachedTorrent) {
-	if err := c.client.GenerateDownloadLinks(t.Torrent); err != nil {
-		c.logger.Error().Err(err).Msg("Failed to generate download links")
-	}
-	for _, file := range t.Files {
-		c.updateDownloadLink(file.Link, file.DownloadLink, file.AccountId)
-	}
-
-	c.SaveTorrent(t)
-}
-
-func (c *Cache) AddTorrent(t *types.Torrent) error {
-	if len(t.Files) == 0 {
-		if err := c.client.UpdateTorrent(t); err != nil {
-			return fmt.Errorf("failed to update torrent: %w", err)
-		}
-	}
-	addedOn, err := time.Parse(time.RFC3339, t.Added)
-	if err != nil {
-		addedOn = time.Now()
-	}
-	ct := &CachedTorrent{
-		Torrent:    t,
-		IsComplete: len(t.Files) > 0,
-		AddedOn:    addedOn,
-	}
-	c.setTorrent(ct)
-	c.refreshListings()
-	go c.GenerateDownloadLinks(ct)
-	return nil
-
-}
-
-func (c *Cache) updateDownloadLink(link, downloadLink string, accountId string) {
-	c.downloadLinks.Store(link, downloadLinkCache{
-		Link:      downloadLink,
-		ExpiresAt: time.Now().Add(c.autoExpiresLinksAfter),
-		AccountId: 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.downloadLinks.Delete(link) // Remove the download link from cache
-}
-
-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
-}
-
-func (c *Cache) GetClient() types.Client {
-	return c.client
-}
-
-func (c *Cache) DeleteTorrent(id string) error {
-	c.logger.Info().Msgf("Deleting torrent %s", id)
-	c.torrentsRefreshMu.Lock()
-	defer c.torrentsRefreshMu.Unlock()
-
-	if t, ok := c.torrents.Load(id); ok {
-		_ = c.client.DeleteTorrent(id) // SKip error handling, we don't care if it fails
-		c.torrents.Delete(id)
-		c.torrentsNames.Delete(c.GetTorrentFolder(t.Torrent))
-		c.removeFromDB(id)
-		c.refreshListings()
-	}
-	return nil
-}
-
-func (c *Cache) DeleteTorrents(ids []string) {
-	c.logger.Info().Msgf("Deleting %d torrents", len(ids))
-	for _, id := range ids {
-		if t, ok := c.torrents.Load(id); ok {
-			c.torrents.Delete(id)
-			c.torrentsNames.Delete(c.GetTorrentFolder(t.Torrent))
-			c.removeFromDB(id)
-		}
-	}
-	c.refreshListings()
-}
-
-func (c *Cache) removeFromDB(torrentId string) {
-	// Moves the torrent file to the trash
-	filePath := filepath.Join(c.dir, torrentId+".json")
-
-	// Check if the file exists
-	if _, err := os.Stat(filePath); errors.Is(err, os.ErrNotExist) {
-		return
-	}
-
-	// Move the file to the trash
-	trashPath := filepath.Join(c.dir, "trash", torrentId+".json")
-	if err := os.MkdirAll(filepath.Dir(trashPath), 0755); err != nil {
-		return
-	}
-	if err := os.Rename(filePath, trashPath); err != nil {
-		return
-	}
-}
-
-func (c *Cache) OnRemove(torrentId string) {
-	c.logger.Debug().Msgf("OnRemove triggered for %s", torrentId)
-	err := c.DeleteTorrent(torrentId)
-	if err != nil {
-		c.logger.Error().Err(err).Msgf("Failed to delete torrent: %s", torrentId)
-		return
-	}
-}
-
-func (c *Cache) GetLogger() zerolog.Logger {
-	return c.logger
-}

pkg/debrid/debrid/debrid.go

@@ -1,86 +0,0 @@
-package debrid
-
-import (
-	"fmt"
-	"github.com/sirrobot01/decypharr/internal/config"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/debrid/alldebrid"
-	"github.com/sirrobot01/decypharr/pkg/debrid/debrid_link"
-	"github.com/sirrobot01/decypharr/pkg/debrid/realdebrid"
-	"github.com/sirrobot01/decypharr/pkg/debrid/torbox"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-)
-
-func createDebridClient(dc config.Debrid) types.Client {
-	switch dc.Name {
-	case "realdebrid":
-		return realdebrid.New(dc)
-	case "torbox":
-		return torbox.New(dc)
-	case "debridlink":
-		return debrid_link.New(dc)
-	case "alldebrid":
-		return alldebrid.New(dc)
-	default:
-		return realdebrid.New(dc)
-	}
-}
-
-func ProcessTorrent(d *Engine, magnet *utils.Magnet, a *arr.Arr, isSymlink, overrideDownloadUncached bool) (*types.Torrent, error) {
-
-	debridTorrent := &types.Torrent{
-		InfoHash: magnet.InfoHash,
-		Magnet:   magnet,
-		Name:     magnet.Name,
-		Arr:      a,
-		Size:     magnet.Size,
-		Files:    make(map[string]types.File),
-	}
-
-	errs := make([]error, 0)
-
-	for index, db := range d.Clients {
-		logger := db.GetLogger()
-		logger.Info().Msgf("Processing debrid: %s", db.GetName())
-
-		// 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 = 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)
-			}
-		}
-
-		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())
-		d.LastUsed = index
-		return db.CheckStatus(dbt, isSymlink)
-	}
-	err := fmt.Errorf("failed to process torrent")
-	for _, e := range errs {
-		err = fmt.Errorf("%w\n%w", err, e)
-	}
-	return nil, err
-}

pkg/debrid/debrid/engine.go

@@ -1,55 +0,0 @@
-package debrid
-
-import (
-	"github.com/sirrobot01/decypharr/internal/config"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-)
-
-type Engine struct {
-	Clients  map[string]types.Client
-	Caches   map[string]*Cache
-	LastUsed string
-}
-
-func NewEngine() *Engine {
-	cfg := config.Get()
-	clients := make(map[string]types.Client)
-
-	caches := make(map[string]*Cache)
-
-	for _, dc := range cfg.Debrids {
-		client := createDebridClient(dc)
-		logger := client.GetLogger()
-		if dc.UseWebDav {
-			caches[dc.Name] = New(dc, client)
-			logger.Info().Msg("Debrid Service started with WebDAV")
-		} else {
-			logger.Info().Msg("Debrid Service started")
-		}
-		clients[dc.Name] = client
-	}
-
-	d := &Engine{
-		Clients:  clients,
-		LastUsed: "",
-		Caches:   caches,
-	}
-	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) GetByName(name string) types.Client {
-	return d.Clients[name]
-}
-
-func (d *Engine) GetDebrids() map[string]types.Client {
-	return d.Clients
-}

pkg/debrid/debrid/refresh.go

@@ -1,249 +0,0 @@
-package debrid
-
-import (
-	"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 {
-	name    string
-	size    int64
-	mode    os.FileMode
-	modTime time.Time
-	isDir   bool
-}
-
-func (fi *fileInfo) Name() string       { return fi.name }
-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) 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
-	})
-
-	// 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
-	}
-}
-
-func (c *Cache) refreshTorrents() {
-	if c.torrentsRefreshMu.TryLock() {
-		defer c.torrentsRefreshMu.Unlock()
-	} else {
-		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
-	})
-
-	// Get new torrents from the debrid service
-	debTorrents, err := c.client.GetTorrents()
-	if err != nil {
-		c.logger.Debug().Err(err).Msg("Failed to get torrents")
-		return
-	}
-
-	if len(debTorrents) == 0 {
-		// Maybe an error occurred
-		return
-	}
-
-	// Get the newly added torrents only
-	_newTorrents := make([]*types.Torrent, 0)
-	idStore := make(map[string]struct{}, len(debTorrents))
-	for _, t := range debTorrents {
-		idStore[t.Id] = struct{}{}
-		if _, ok := torrents[t.Id]; !ok {
-			_newTorrents = append(_newTorrents, t)
-		}
-	}
-
-	// Check for deleted torrents
-	deletedTorrents := make([]string, 0)
-	for id := range torrents {
-		if _, ok := idStore[id]; !ok {
-			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)
-	}
-
-	if len(newTorrents) == 0 {
-		return
-	}
-	c.logger.Info().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
-
-	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)
-					errChan <- err
-				}
-			}
-		}()
-	}
-
-	for _, t := range newTorrents {
-		select {
-		case <-c.ctx.Done():
-			break
-		default:
-			workChan <- t
-		}
-	}
-	close(workChan)
-	wg.Wait()
-
-	c.logger.Debug().Msgf("Processed %d new torrents", len(newTorrents))
-}
-
-func (c *Cache) RefreshRclone() error {
-	client := request.Default()
-	cfg := config.Get().WebDav
-
-	if cfg.RcUrl == "" {
-		return nil
-	}
-	// Create form data
-	data := "dir=__all__&dir2=torrents"
-
-	// 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 {
-		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 {
-		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)
-	if err != nil {
-		c.logger.Debug().Msgf("Failed to get torrent files for %s: %v", t.Id, err)
-		return nil
-	}
-	if len(t.Files) == 0 {
-		return nil
-	}
-	addedOn, err := time.Parse(time.RFC3339, _torrent.Added)
-	if err != nil {
-		addedOn = time.Now()
-	}
-	ct := &CachedTorrent{
-		Torrent:    _torrent,
-		AddedOn:    addedOn,
-		IsComplete: len(t.Files) > 0,
-	}
-	c.setTorrent(ct)
-
-	return ct
-}
-
-func (c *Cache) refreshDownloadLinks() {
-	if c.downloadLinksRefreshMu.TryLock() {
-		defer c.downloadLinksRefreshMu.Unlock()
-	} else {
-		return
-	}
-
-	downloadLinks, err := c.client.GetDownloads()
-	if err != nil {
-		c.logger.Debug().Err(err).Msg("Failed to get download links")
-	}
-	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),
-			})
-		} else {
-			c.downloadLinks.Delete(k)
-		}
-	}
-
-	c.logger.Debug().Msgf("Refreshed %d download links", len(downloadLinks))
-
-}

pkg/debrid/debrid/repair.go

@@ -1,168 +0,0 @@
-package debrid
-
-import (
-	"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"
-	"time"
-)
-
-func (c *Cache) IsTorrentBroken(t *CachedTorrent, filenames []string) bool {
-	// Check torrent files
-
-	isBroken := false
-	files := make(map[string]types.File)
-	if len(filenames) > 0 {
-		for name, f := range t.Files {
-			if slices.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
-		}
-	}
-
-	files = t.Files
-
-	for _, f := range files {
-		// Check if file link is still missing
-		if f.Link == "" {
-			isBroken = true
-			break
-		} 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
-				}
-			}
-		}
-	}
-	return isBroken
-}
-
-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
-		}
-
-		// Mark as in progress
-		c.repairsInProgress.Store(torrentId, struct{}{})
-		c.logger.Debug().Str("torrentId", req.TorrentID).Msg("Received repair request")
-
-		// 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
-		}
-
-		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")
-				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) {
-	// 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)
-	}
-
-	if torrent.Magnet == nil {
-		torrent.Magnet = utils.ConstructMagnet(torrent.InfoHash, torrent.Name)
-	}
-
-	oldID := torrent.Id
-	defer func() {
-		err := c.DeleteTorrent(oldID)
-		if err != nil {
-			c.logger.Error().Err(err).Str("torrentId", oldID).Msg("Failed to delete old torrent")
-		}
-	}()
-
-	// Submit the magnet to the debrid service
-	torrent.Id = ""
-	var err error
-	torrent, err = c.client.SubmitMagnet(torrent)
-	if err != nil {
-		// Remove the old torrent from the cache and debrid service
-		return nil, 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")
-	}
-	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")
-	}
-
-	// 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")
-		}
-	}
-	if err != nil {
-		addedOn = time.Now()
-	}
-	ct := &CachedTorrent{
-		Torrent:    torrent,
-		IsComplete: len(torrent.Files) > 0,
-		AddedOn:    addedOn,
-	}
-	c.setTorrent(ct)
-	c.refreshListings()
-	return ct, nil
-}
-
-func (c *Cache) resetInvalidLinks() {
-	c.invalidDownloadLinks = xsync.NewMapOf[string, string]()
-	c.client.ResetActiveDownloadKeys() // Reset the active download keys
-}

pkg/debrid/debrid/worker.go

@@ -1,75 +0,0 @@
-package debrid
-
-import "time"
-
-func (c *Cache) Refresh() error {
-	// For now, we just want to refresh the listing and download links
-	//go c.refreshDownloadLinksWorker()
-	go c.refreshTorrentsWorker()
-	go c.resetInvalidLinksWorker()
-	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 +0,0 @@
-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/providers/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,26 +12,32 @@ import (
 	"net/http"
 	gourl "net/url"
 	"path/filepath"
-	"slices"
 	"strconv"
 	"sync"
 	"time"
 )
 
 type AllDebrid struct {
-	Name             string
-	Host             string `json:"host"`
-	APIKey           string
-	DownloadKeys     *xsync.MapOf[string, types.Account]
-	DownloadUncached bool
-	client           *request.Client
+	name                  string
+	Host                  string `json:"host"`
+	APIKey                string
+	accounts              *types.Accounts
+	autoExpiresLinksAfter time.Duration
+	DownloadUncached      bool
+	client                *request.Client
 
-	MountPath   string
-	logger      zerolog.Logger
-	CheckCached bool
+	MountPath       string
+	logger          zerolog.Logger
+	checkCached     bool
+	addSamples      bool
+	minimumFreeSlot int
 }
 
-func New(dc config.Debrid) *AllDebrid {
+func (ad *AllDebrid) GetProfile() (*types.Profile, error) {
+	return nil, nil
+}
+
+func New(dc config.Debrid) (*AllDebrid, error) {
 	rl := request.ParseRateLimit(dc.RateLimit)
 
 	headers := map[string]string{
@@ -46,33 +51,31 @@ func New(dc config.Debrid) *AllDebrid {
 		request.WithProxy(dc.Proxy),
 	)
 
-	accounts := xsync.NewMapOf[string, types.Account]()
-	for idx, key := range dc.DownloadAPIKeys {
-		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
-			Name:  key,
-			ID:    id,
-			Token: key,
-		})
+	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
+	if autoExpiresLinksAfter == 0 || err != nil {
+		autoExpiresLinksAfter = 48 * time.Hour
 	}
 	return &AllDebrid{
-		Name:             "alldebrid",
-		Host:             dc.Host,
-		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
-		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-		MountPath:        dc.Folder,
-		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
-	}
+		name:                  "alldebrid",
+		Host:                  "http://api.alldebrid.com/v4.1",
+		APIKey:                dc.APIKey,
+		accounts:              types.NewAccounts(dc),
+		DownloadUncached:      dc.DownloadUncached,
+		autoExpiresLinksAfter: autoExpiresLinksAfter,
+		client:                client,
+		MountPath:             dc.Folder,
+		logger:                logger.New(dc.Name),
+		checkCached:           dc.CheckCached,
+		addSamples:            dc.AddSamples,
+		minimumFreeSlot:       dc.MinimumFreeSlot,
+	}, nil
 }
 
-func (ad *AllDebrid) GetName() string {
-	return ad.Name
+func (ad *AllDebrid) Name() string {
+	return ad.name
 }
 
-func (ad *AllDebrid) GetLogger() zerolog.Logger {
+func (ad *AllDebrid) Logger() zerolog.Logger {
 	return ad.logger
 }
 
@@ -122,7 +125,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 +138,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 +152,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 +165,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 +179,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.Error().Err(err).Msgf("Error unmarshalling torrent info")
+		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)
@@ -185,7 +231,7 @@ func (ad *AllDebrid) UpdateTorrent(t *types.Torrent) error {
 	var res TorrentInfoResponse
 	err = json.Unmarshal(resp, &res)
 	if err != nil {
-		ad.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
+		ad.logger.Error().Err(err).Msgf("Error unmarshalling torrent info")
 		return err
 	}
 	data := res.Data.Magnets
@@ -197,21 +243,23 @@ func (ad *AllDebrid) UpdateTorrent(t *types.Torrent) error {
 	t.OriginalFilename = name
 	t.Folder = name
 	t.MountPath = ad.MountPath
-	t.Debrid = ad.Name
+	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
 }
 
-func (ad *AllDebrid) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.Torrent, error) {
+func (ad *AllDebrid) CheckStatus(torrent *types.Torrent) (*types.Torrent, error) {
 	for {
 		err := ad.UpdateTorrent(torrent)
 
@@ -221,14 +269,8 @@ func (ad *AllDebrid) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types
 		status := torrent.Status
 		if status == "downloaded" {
 			ad.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			if !isSymlink {
-				err = ad.GenerateDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if slices.Contains(ad.GetDownloadingStatus(), status) {
+			return torrent, nil
+		} else if utils.Contains(ad.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -240,7 +282,6 @@ func (ad *AllDebrid) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types
 		}
 
 	}
-	return torrent, nil
 }
 
 func (ad *AllDebrid) DeleteTorrent(torrentId string) error {
@@ -253,8 +294,9 @@ func (ad *AllDebrid) DeleteTorrent(torrentId string) error {
 	return nil
 }
 
-func (ad *AllDebrid) GenerateDownloadLinks(t *types.Torrent) error {
+func (ad *AllDebrid) GetFileDownloadLinks(t *types.Torrent) error {
 	filesCh := make(chan types.File, len(t.Files))
+	linksCh := make(chan *types.DownloadLink, len(t.Files))
 	errCh := make(chan error, len(t.Files))
 
 	var wg sync.WaitGroup
@@ -262,24 +304,24 @@ 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
 			}
+			linksCh <- link
+			file.DownloadLink = link
 			filesCh <- file
 		}(file)
 	}
 	go func() {
 		wg.Wait()
 		close(filesCh)
+		close(linksCh)
 		close(errCh)
 	}()
 	files := make(map[string]types.File, len(t.Files))
@@ -287,10 +329,22 @@ func (ad *AllDebrid) GenerateDownloadLinks(t *types.Torrent) error {
 		files[file.Name] = file
 	}
 
+	// Collect download links
+	links := make(map[string]*types.DownloadLink, len(t.Files))
+
+	for link := range linksCh {
+		if link == nil {
+			continue
+		}
+		links[link.Link] = link
+	}
+	// Update the files with download links
+	ad.accounts.SetDownloadLinks(links)
+
 	// Check for errors
 	for err := range errCh {
 		if err != nil {
-			return err // Return the first error encountered
+			return err
 		}
 	}
 
@@ -298,7 +352,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 +360,30 @@ 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
-}
-
-func (ad *AllDebrid) GetCheckCached() bool {
-	return ad.CheckCached
+	now := time.Now()
+	return &types.DownloadLink{
+		Link:         file.Link,
+		DownloadLink: link,
+		Id:           data.Data.Id,
+		Size:         file.Size,
+		Filename:     file.Name,
+		Generated:    now,
+		ExpiresAt:    now.Add(ad.autoExpiresLinksAfter),
+	}, nil
 }
 
 func (ad *AllDebrid) GetTorrents() ([]*types.Torrent, error) {
@@ -334,7 +397,7 @@ func (ad *AllDebrid) GetTorrents() ([]*types.Torrent, error) {
 	var res TorrentsListResponse
 	err = json.Unmarshal(resp, &res)
 	if err != nil {
-		ad.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
+		ad.logger.Error().Err(err).Msgf("Error unmarshalling torrent info")
 		return torrents, err
 	}
 	for _, magnet := range res.Data.Magnets {
@@ -347,15 +410,16 @@ func (ad *AllDebrid) GetTorrents() ([]*types.Torrent, error) {
 			OriginalFilename: magnet.Filename,
 			Files:            make(map[string]types.File),
 			InfoHash:         magnet.Hash,
-			Debrid:           ad.Name,
+			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) GetDownloadLinks() (map[string]*types.DownloadLink, error) {
 	return nil, nil
 }
 
@@ -375,9 +439,16 @@ func (ad *AllDebrid) GetMountPath() string {
 	return ad.MountPath
 }
 
-func (ad *AllDebrid) DisableAccount(accountId string) {
+func (ad *AllDebrid) DeleteDownloadLink(linkId string) error {
+	return nil
 }
 
-func (ad *AllDebrid) ResetActiveDownloadKeys() {
-
+func (ad *AllDebrid) GetAvailableSlots() (int, error) {
+	// This function is a placeholder for AllDebrid
+	//TODO: Implement the logic to check available slots for AllDebrid
+	return 0, fmt.Errorf("GetAvailableSlots not implemented for AllDebrid")
+}
+
+func (ad *AllDebrid) Accounts() *types.Accounts {
+	return ad.accounts
 }

pkg/debrid/providers/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/providers/debrid_link/debrid_link.go

@@ -2,17 +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"
 
 	"net/http"
@@ -20,23 +17,64 @@ import (
 )
 
 type DebridLink struct {
-	Name             string
+	name             string
 	Host             string `json:"host"`
 	APIKey           string
-	DownloadKeys     *xsync.MapOf[string, types.Account]
+	accounts         *types.Accounts
 	DownloadUncached bool
 	client           *request.Client
 
+	autoExpiresLinksAfter time.Duration
+
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
-func (dl *DebridLink) GetName() string {
-	return dl.Name
+func New(dc config.Debrid) (*DebridLink, error) {
+	rl := request.ParseRateLimit(dc.RateLimit)
+
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+		"Content-Type":  "application/json",
+	}
+	_log := logger.New(dc.Name)
+	client := request.New(
+		request.WithHeaders(headers),
+		request.WithLogger(_log),
+		request.WithRateLimiter(rl),
+		request.WithProxy(dc.Proxy),
+	)
+
+	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
+	if autoExpiresLinksAfter == 0 || err != nil {
+		autoExpiresLinksAfter = 48 * time.Hour
+	}
+	return &DebridLink{
+		name:                  "debridlink",
+		Host:                  "https://debrid-link.com/api/v2",
+		APIKey:                dc.APIKey,
+		accounts:              types.NewAccounts(dc),
+		DownloadUncached:      dc.DownloadUncached,
+		autoExpiresLinksAfter: autoExpiresLinksAfter,
+		client:                client,
+		MountPath:             dc.Folder,
+		logger:                logger.New(dc.Name),
+		checkCached:           dc.CheckCached,
+		addSamples:            dc.AddSamples,
+	}, nil
 }
 
-func (dl *DebridLink) GetLogger() zerolog.Logger {
+func (dl *DebridLink) GetProfile() (*types.Profile, error) {
+	return nil, nil
+}
+
+func (dl *DebridLink) Name() string {
+	return dl.name
+}
+
+func (dl *DebridLink) Logger() zerolog.Logger {
 	return dl.logger
 }
 
@@ -69,13 +107,13 @@ func (dl *DebridLink) IsAvailable(hashes []string) map[string]bool {
 		req, _ := http.NewRequest(http.MethodGet, url, nil)
 		resp, err := dl.client.MakeRequest(req)
 		if err != nil {
-			dl.logger.Info().Msgf("Error checking availability: %v", err)
+			dl.logger.Error().Err(err).Msgf("Error checking availability")
 			return result
 		}
 		var data AvailableResponse
 		err = json.Unmarshal(resp, &data)
 		if err != nil {
-			dl.logger.Info().Msgf("Error marshalling availability: %v", err)
+			dl.logger.Error().Err(err).Msgf("Error marshalling availability")
 			return result
 		}
 		if data.Value == nil {
@@ -92,6 +130,58 @@ 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,
+			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 +189,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,21 +221,35 @@ 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()
+	links := make(map[string]*types.DownloadLink)
+	now := time.Now()
 	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,
+			Link:      f.DownloadURL,
 		}
+		link := &types.DownloadLink{
+			Filename:     f.Name,
+			Link:         f.DownloadURL,
+			DownloadLink: f.DownloadURL,
+			Generated:    now,
+			ExpiresAt:    now.Add(dl.autoExpiresLinksAfter),
+		}
+		links[file.Link] = link
+		file.DownloadLink = link
 		t.Files[f.Name] = file
 	}
+
+	dl.accounts.SetDownloadLinks(links)
 	return nil
 }
 
@@ -180,24 +284,39 @@ func (dl *DebridLink) SubmitMagnet(t *types.Torrent) (*types.Torrent, error) {
 	t.Filename = name
 	t.OriginalFilename = name
 	t.MountPath = dl.MountPath
-	t.Debrid = dl.Name
+	t.Debrid = dl.name
+	t.Added = time.Unix(data.Created, 0).Format(time.RFC3339)
+
+	links := make(map[string]*types.DownloadLink)
+	now := time.Now()
 	for _, f := range data.Files {
 		file := types.File{
-			Id:           f.ID,
-			Name:         f.Name,
-			Size:         f.Size,
-			Path:         f.Name,
+			TorrentId: t.Id,
+			Id:        f.ID,
+			Name:      f.Name,
+			Size:      f.Size,
+			Path:      f.Name,
+			Link:      f.DownloadURL,
+			Generated: now,
+		}
+		link := &types.DownloadLink{
+			Filename:     f.Name,
 			Link:         f.DownloadURL,
 			DownloadLink: f.DownloadURL,
-			Generated:    time.Now(),
+			Generated:    now,
+			ExpiresAt:    now.Add(dl.autoExpiresLinksAfter),
 		}
+		links[file.Link] = link
+		file.DownloadLink = link
 		t.Files[f.Name] = file
 	}
 
+	dl.accounts.SetDownloadLinks(links)
+
 	return t, nil
 }
 
-func (dl *DebridLink) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.Torrent, error) {
+func (dl *DebridLink) CheckStatus(torrent *types.Torrent) (*types.Torrent, error) {
 	for {
 		err := dl.UpdateTorrent(torrent)
 		if err != nil || torrent == nil {
@@ -206,12 +325,8 @@ func (dl *DebridLink) CheckStatus(torrent *types.Torrent, isSymlink bool) (*type
 		status := torrent.Status
 		if status == "downloaded" {
 			dl.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			err = dl.GenerateDownloadLinks(torrent)
-			if err != nil {
-				return torrent, err
-			}
-			break
-		} else if slices.Contains(dl.GetDownloadingStatus(), status) {
+			return torrent, nil
+		} else if utils.Contains(dl.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -223,7 +338,6 @@ func (dl *DebridLink) CheckStatus(torrent *types.Torrent, isSymlink bool) (*type
 		}
 
 	}
-	return torrent, nil
 }
 
 func (dl *DebridLink) DeleteTorrent(torrentId string) error {
@@ -236,68 +350,27 @@ func (dl *DebridLink) DeleteTorrent(torrentId string) error {
 	return nil
 }
 
-func (dl *DebridLink) GenerateDownloadLinks(t *types.Torrent) error {
+func (dl *DebridLink) GetFileDownloadLinks(t *types.Torrent) error {
 	// Download links are already generated
 	return nil
 }
 
-func (dl *DebridLink) GetDownloads() (map[string]types.DownloadLinks, error) {
+func (dl *DebridLink) GetDownloadLinks() (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 dl.accounts.GetDownloadLink(file.Link)
 }
 
 func (dl *DebridLink) GetDownloadingStatus() []string {
 	return []string{"downloading"}
 }
 
-func (dl *DebridLink) GetCheckCached() bool {
-	return dl.CheckCached
-}
-
 func (dl *DebridLink) GetDownloadUncached() bool {
 	return dl.DownloadUncached
 }
 
-func New(dc config.Debrid) *DebridLink {
-	rl := request.ParseRateLimit(dc.RateLimit)
-
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-		"Content-Type":  "application/json",
-	}
-	_log := logger.New(dc.Name)
-	client := request.New(
-		request.WithHeaders(headers),
-		request.WithLogger(_log),
-		request.WithRateLimiter(rl),
-		request.WithProxy(dc.Proxy),
-	)
-
-	accounts := xsync.NewMapOf[string, types.Account]()
-	for idx, key := range dc.DownloadAPIKeys {
-		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
-			Name:  key,
-			ID:    id,
-			Token: key,
-		})
-	}
-	return &DebridLink{
-		Name:             "debridlink",
-		Host:             dc.Host,
-		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
-		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-		MountPath:        dc.Folder,
-		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
-	}
-}
-
 func (dl *DebridLink) GetTorrents() ([]*types.Torrent, error) {
 	page := 0
 	perPage := 100
@@ -324,14 +397,15 @@ 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)
+		dl.logger.Error().Err(err).Msgf("Error unmarshalling torrent info")
 		return torrents, err
 	}
 
 	data := *res.Value
+	links := make(map[string]*types.DownloadLink)
 
 	if len(data) == 0 {
 		return torrents, nil
@@ -349,26 +423,39 @@ func (dl *DebridLink) getTorrents(page, perPage int) ([]*types.Torrent, error) {
 			OriginalFilename: t.Name,
 			InfoHash:         t.HashString,
 			Files:            make(map[string]types.File),
-			Debrid:           dl.Name,
+			Debrid:           dl.name,
 			MountPath:        dl.MountPath,
+			Added:            time.Unix(t.Created, 0).Format(time.RFC3339),
 		}
 		cfg := config.Get()
+		now := time.Now()
 		for _, f := range t.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: torrent.Id,
+				Id:        f.ID,
+				Name:      f.Name,
+				Size:      f.Size,
+				Path:      f.Name,
+				Link:      f.DownloadURL,
 			}
+			link := &types.DownloadLink{
+				Filename:     f.Name,
+				Link:         f.DownloadURL,
+				DownloadLink: f.DownloadURL,
+				Generated:    now,
+				ExpiresAt:    now.Add(dl.autoExpiresLinksAfter),
+			}
+			links[file.Link] = link
+			file.DownloadLink = link
 			torrent.Files[f.Name] = file
 		}
 		torrents = append(torrents, torrent)
 	}
+	dl.accounts.SetDownloadLinks(links)
+
 	return torrents, nil
 }
 
@@ -380,8 +467,15 @@ func (dl *DebridLink) GetMountPath() string {
 	return dl.MountPath
 }
 
-func (dl *DebridLink) DisableAccount(accountId string) {
+func (dl *DebridLink) DeleteDownloadLink(linkId string) error {
+	return nil
 }
 
-func (dl *DebridLink) ResetActiveDownloadKeys() {
+func (dl *DebridLink) GetAvailableSlots() (int, error) {
+	//TODO: Implement the logic to check available slots for DebridLink
+	return 0, fmt.Errorf("GetAvailableSlots not implemented for DebridLink")
+}
+
+func (dl *DebridLink) Accounts() *types.Accounts {
+	return dl.accounts
 }

pkg/debrid/providers/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/providers/realdebrid/misc.go

@@ -0,0 +1 @@
+package realdebrid

pkg/debrid/providers/realdebrid/realdebrid.go

@@ -0,0 +1,955 @@
+package realdebrid
+
+import (
+	"bytes"
+	"cmp"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"io"
+	"net/http"
+	gourl "net/url"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"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/rar"
+)
+
+type RealDebrid struct {
+	name string
+	Host string `json:"host"`
+
+	APIKey   string
+	accounts *types.Accounts
+
+	DownloadUncached      bool
+	client                *request.Client
+	downloadClient        *request.Client
+	repairClient          *request.Client
+	autoExpiresLinksAfter time.Duration
+
+	MountPath string
+	logger    zerolog.Logger
+	UnpackRar bool
+
+	rarSemaphore    chan struct{}
+	checkCached     bool
+	addSamples      bool
+	Profile         *types.Profile
+	minimumFreeSlot int // Minimum number of active pots to maintain (used for cached stuffs, etc.)
+
+}
+
+func New(dc config.Debrid) (*RealDebrid, error) {
+	rl := request.ParseRateLimit(dc.RateLimit)
+	repairRl := request.ParseRateLimit(cmp.Or(dc.RepairRateLimit, dc.RateLimit))
+	downloadRl := request.ParseRateLimit(cmp.Or(dc.DownloadRateLimit, dc.RateLimit))
+
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+	}
+	_log := logger.New(dc.Name)
+
+	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
+	if autoExpiresLinksAfter == 0 || err != nil {
+		autoExpiresLinksAfter = 48 * time.Hour
+	}
+
+	r := &RealDebrid{
+		name:                  "realdebrid",
+		Host:                  "https://api.real-debrid.com/rest/1.0",
+		APIKey:                dc.APIKey,
+		accounts:              types.NewAccounts(dc),
+		DownloadUncached:      dc.DownloadUncached,
+		autoExpiresLinksAfter: autoExpiresLinksAfter,
+		UnpackRar:             dc.UnpackRar,
+		client: request.New(
+			request.WithHeaders(headers),
+			request.WithRateLimiter(rl),
+			request.WithLogger(_log),
+			request.WithMaxRetries(10),
+			request.WithRetryableStatus(429, 502),
+			request.WithProxy(dc.Proxy),
+		),
+		downloadClient: request.New(
+			request.WithRateLimiter(downloadRl),
+			request.WithLogger(_log),
+			request.WithMaxRetries(10),
+			request.WithRetryableStatus(429, 447, 502),
+			request.WithProxy(dc.Proxy),
+		),
+		repairClient: request.New(
+			request.WithRateLimiter(repairRl),
+			request.WithHeaders(headers),
+			request.WithLogger(_log),
+			request.WithMaxRetries(4),
+			request.WithRetryableStatus(429, 502),
+			request.WithProxy(dc.Proxy),
+		),
+		MountPath:       dc.Folder,
+		logger:          logger.New(dc.Name),
+		rarSemaphore:    make(chan struct{}, 2),
+		checkCached:     dc.CheckCached,
+		addSamples:      dc.AddSamples,
+		minimumFreeSlot: dc.MinimumFreeSlot,
+	}
+
+	if _, err := r.GetProfile(); err != nil {
+		return nil, err
+	} else {
+		return r, nil
+	}
+}
+
+func (r *RealDebrid) Name() string {
+	return r.name
+}
+
+func (r *RealDebrid) Logger() zerolog.Logger {
+	return r.logger
+}
+
+func (r *RealDebrid) getSelectedFiles(t *types.Torrent, data torrentInfo) (map[string]types.File, error) {
+	files := make(map[string]types.File)
+	selectedFiles := make([]types.File, 0)
+
+	for _, f := range data.Files {
+		if f.Selected == 1 {
+			selectedFiles = append(selectedFiles, types.File{
+				TorrentId: t.Id,
+				Name:      filepath.Base(f.Path),
+				Path:      filepath.Base(f.Path),
+				Size:      f.Bytes,
+				Id:        strconv.Itoa(f.ID),
+			})
+		}
+	}
+
+	if len(selectedFiles) == 0 {
+		return files, nil
+	}
+
+	// Handle RARed torrents (single link, multiple files)
+	if len(data.Links) == 1 && len(selectedFiles) > 1 {
+		return r.handleRarArchive(t, data, selectedFiles)
+	}
+
+	// Standard case - map files to links
+	if len(selectedFiles) > len(data.Links) {
+		r.logger.Warn().Msgf("More files than links available: %d files, %d links for %s", len(selectedFiles), len(data.Links), t.Name)
+	}
+
+	for i, f := range selectedFiles {
+		if i < len(data.Links) {
+			f.Link = data.Links[i]
+			files[f.Name] = f
+		} else {
+			r.logger.Warn().Str("file", f.Name).Msg("No link available for file")
+		}
+	}
+
+	return files, nil
+}
+
+// handleRarArchive processes RAR archives with multiple files
+func (r *RealDebrid) handleRarArchive(t *types.Torrent, data torrentInfo, selectedFiles []types.File) (map[string]types.File, error) {
+	// This will block if 2 RAR operations are already in progress
+	r.rarSemaphore <- struct{}{}
+	defer func() {
+		<-r.rarSemaphore
+	}()
+
+	files := make(map[string]types.File)
+
+	if !r.UnpackRar {
+		r.logger.Debug().Msgf("RAR file detected, but unpacking is disabled: %s", t.Name)
+		// Create a single file representing the RAR archive
+		file := types.File{
+			TorrentId: t.Id,
+			Id:        "0",
+			Name:      t.Name + ".rar",
+			Size:      0,
+			IsRar:     true,
+			ByteRange: nil,
+			Path:      t.Name + ".rar",
+			Link:      data.Links[0],
+			Generated: time.Now(),
+		}
+		files[file.Name] = file
+		return files, nil
+	}
+
+	r.logger.Info().Msgf("RAR file detected, unpacking: %s", t.Name)
+	linkFile := &types.File{TorrentId: t.Id, Link: data.Links[0]}
+	downloadLinkObj, err := r.GetDownloadLink(t, linkFile)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to get download link for RAR file: %w", err)
+	}
+
+	dlLink := downloadLinkObj.DownloadLink
+	reader, err := rar.NewReader(dlLink)
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to create RAR reader: %w", err)
+	}
+
+	rarFiles, err := reader.GetFiles()
+
+	if err != nil {
+		return nil, fmt.Errorf("failed to read RAR files: %w", err)
+	}
+
+	// Create lookup map for faster matching
+	fileMap := make(map[string]*types.File)
+	for i := range selectedFiles {
+		// RD converts special chars to '_' for RAR file paths
+		// @TODO: there might be more special chars to replace
+		safeName := strings.NewReplacer("|", "_", "\"", "_", "\\", "_", "?", "_", "*", "_", ":", "_", "<", "_", ">", "_").Replace(selectedFiles[i].Name)
+		fileMap[safeName] = &selectedFiles[i]
+	}
+
+	now := time.Now()
+
+	for _, rarFile := range rarFiles {
+		if file, exists := fileMap[rarFile.Name()]; exists {
+			file.IsRar = true
+			file.ByteRange = rarFile.ByteRange()
+			file.Link = data.Links[0]
+			file.Generated = now
+			files[file.Name] = *file
+		} else if !rarFile.IsDirectory {
+			r.logger.Warn().Msgf("RAR file %s not found in torrent files", rarFile.Name())
+		}
+	}
+
+	return files, nil
+}
+
+// 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 (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 !r.addSamples && utils.IsSampleFile(f.Path) {
+			// Skip sample files
+			continue
+		}
+
+		if !cfg.IsAllowedFile(name) {
+			continue
+		}
+		if !cfg.IsSizeAllowed(f.Bytes) {
+			continue
+		}
+
+		file := types.File{
+			TorrentId: t.Id,
+			Name:      name,
+			Path:      name,
+			Size:      f.Bytes,
+			Id:        strconv.Itoa(f.ID),
+		}
+		files[name] = file
+		idx++
+	}
+	return files
+}
+
+func (r *RealDebrid) IsAvailable(hashes []string) map[string]bool {
+	// Check if the infohashes are available in the local cache
+	result := make(map[string]bool)
+
+	// Divide hashes into groups of 100
+	for i := 0; i < len(hashes); i += 200 {
+		end := i + 200
+		if end > len(hashes) {
+			end = len(hashes)
+		}
+
+		// Filter out empty strings
+		validHashes := make([]string, 0, end-i)
+		for _, hash := range hashes[i:end] {
+			if hash != "" {
+				validHashes = append(validHashes, hash)
+			}
+		}
+
+		// If no valid hashes in this batch, continue to the next batch
+		if len(validHashes) == 0 {
+			continue
+		}
+
+		hashStr := strings.Join(validHashes, "/")
+		url := fmt.Sprintf("%s/torrents/instantAvailability/%s", r.Host, hashStr)
+		req, _ := http.NewRequest(http.MethodGet, url, nil)
+		resp, err := r.client.MakeRequest(req)
+		if err != nil {
+			r.logger.Error().Err(err).Msgf("Error checking availability")
+			return result
+		}
+		var data AvailabilityResponse
+		err = json.Unmarshal(resp, &data)
+		if err != nil {
+			r.logger.Error().Err(err).Msgf("Error marshalling availability")
+			return result
+		}
+		for _, h := range hashes[i:end] {
+			hosters, exists := data[strings.ToLower(h)]
+			if exists && len(hosters.Rd) > 0 {
+				result[h] = true
+			}
+		}
+	}
+	return result
+}
+
+func (r *RealDebrid) SubmitMagnet(t *types.Torrent) (*types.Torrent, error) {
+	if t.Magnet.IsTorrent() {
+		return r.addTorrent(t)
+	}
+	return r.addMagnet(t)
+}
+
+func (r *RealDebrid) addTorrent(t *types.Torrent) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents/addTorrent", r.Host)
+	var data AddMagnetSchema
+	req, err := http.NewRequest(http.MethodPut, url, bytes.NewReader(t.Magnet.File))
+
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Add("Content-Type", "application/x-bittorrent")
+	resp, err := r.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		// Handle multiple_downloads
+
+		if resp.StatusCode == 509 {
+			return nil, utils.TooManyActiveDownloadsError
+		}
+
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("realdebrid API error: Status: %d || Body: %s", resp.StatusCode, string(bodyBytes))
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("reading response body: %w", err)
+	}
+	if err = json.Unmarshal(bodyBytes, &data); err != nil {
+		return nil, err
+	}
+	t.Id = data.Id
+	t.Debrid = r.name
+	t.MountPath = r.MountPath
+	return t, nil
+}
+
+func (r *RealDebrid) addMagnet(t *types.Torrent) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents/addMagnet", r.Host)
+	payload := gourl.Values{
+		"magnet": {t.Magnet.Link},
+	}
+	var data AddMagnetSchema
+	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
+	resp, err := r.client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		// Handle multiple_downloads
+
+		if resp.StatusCode == 509 {
+			return nil, utils.TooManyActiveDownloadsError
+		}
+
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("realdebrid API error: Status: %d || Body: %s", resp.StatusCode, string(bodyBytes))
+	}
+	defer resp.Body.Close()
+	bodyBytes, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("reading response body: %w", err)
+	}
+	if err = json.Unmarshal(bodyBytes, &data); err != nil {
+		return nil, err
+	}
+	t.Id = data.Id
+	t.Debrid = r.name
+	t.MountPath = r.MountPath
+	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, utils.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.Do(req)
+	if err != nil {
+		return err
+	}
+	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 utils.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
+	}
+	t.Name = data.Filename
+	t.Bytes = data.Bytes
+	t.Folder = data.OriginalFilename
+	t.Progress = data.Progress
+	t.Status = data.Status
+	t.Speed = data.Speed
+	t.Seeders = data.Seeders
+	t.Filename = data.Filename
+	t.OriginalFilename = data.OriginalFilename
+	t.Links = data.Links
+	t.MountPath = r.MountPath
+	t.Debrid = r.name
+	t.Added = data.Added
+	t.Files, _ = r.getSelectedFiles(t, data) // Get selected files
+
+	return nil
+}
+
+func (r *RealDebrid) CheckStatus(t *types.Torrent) (*types.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, t.Id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	for {
+		resp, err := r.client.MakeRequest(req)
+		if err != nil {
+			r.logger.Info().Msgf("ERROR Checking file: %v", err)
+			return t, err
+		}
+		var data torrentInfo
+		if err = json.Unmarshal(resp, &data); err != nil {
+			return t, err
+		}
+		status := data.Status
+		t.Name = data.Filename // Important because some magnet changes the name
+		t.Folder = data.OriginalFilename
+		t.Filename = data.Filename
+		t.OriginalFilename = data.OriginalFilename
+		t.Bytes = data.Bytes
+		t.Progress = data.Progress
+		t.Speed = data.Speed
+		t.Seeders = data.Seeders
+		t.Links = data.Links
+		t.Status = status
+		t.Debrid = r.name
+		t.MountPath = r.MountPath
+		if status == "waiting_files_selection" {
+			t.Files = r.getTorrentFiles(t, data)
+			if len(t.Files) == 0 {
+				return t, fmt.Errorf("no video files found")
+			}
+			filesId := make([]string, 0)
+			for _, f := range t.Files {
+				filesId = append(filesId, f.Id)
+			}
+			p := gourl.Values{
+				"files": {strings.Join(filesId, ",")},
+			}
+			payload := strings.NewReader(p.Encode())
+			req, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/torrents/selectFiles/%s", r.Host, t.Id), payload)
+			res, err := r.client.Do(req)
+			if err != nil {
+				return t, err
+			}
+			if res.StatusCode != http.StatusNoContent {
+				if res.StatusCode == 509 {
+					return nil, utils.TooManyActiveDownloadsError
+				}
+				return t, fmt.Errorf("realdebrid API error: Status: %d", res.StatusCode)
+			}
+		} else if status == "downloaded" {
+			t.Files, err = r.getSelectedFiles(t, data) // Get selected files
+			if err != nil {
+				return t, err
+			}
+
+			r.logger.Info().Msgf("Torrent: %s downloaded to RD", t.Name)
+			return t, nil
+		} else if utils.Contains(r.GetDownloadingStatus(), status) {
+			if !t.DownloadUncached {
+				return t, fmt.Errorf("torrent: %s not cached", t.Name)
+			}
+			return t, nil
+		} else {
+			return t, fmt.Errorf("torrent: %s has error: %s", t.Name, status)
+		}
+
+	}
+}
+
+func (r *RealDebrid) DeleteTorrent(torrentId string) error {
+	url := fmt.Sprintf("%s/torrents/delete/%s", r.Host, torrentId)
+	req, _ := http.NewRequest(http.MethodDelete, url, nil)
+	if _, err := r.client.MakeRequest(req); err != nil {
+		return err
+	}
+	r.logger.Info().Msgf("Torrent: %s deleted from RD", torrentId)
+	return nil
+}
+
+func (r *RealDebrid) GetFileDownloadLinks(t *types.Torrent) error {
+	var wg sync.WaitGroup
+	var mu sync.Mutex
+	var firstErr error
+
+	files := make(map[string]types.File)
+	links := make(map[string]*types.DownloadLink)
+
+	_files := t.GetFiles()
+	wg.Add(len(_files))
+
+	for _, f := range _files {
+		go func(file types.File) {
+			defer wg.Done()
+
+			link, err := r.GetDownloadLink(t, &file)
+			if err != nil {
+				mu.Lock()
+				if firstErr == nil {
+					firstErr = err
+				}
+				mu.Unlock()
+				return
+			}
+			if link == nil {
+				mu.Lock()
+				if firstErr == nil {
+					firstErr = fmt.Errorf("realdebrid API error: download link not found for file %s", file.Name)
+				}
+				mu.Unlock()
+				return
+			}
+
+			file.DownloadLink = link
+
+			mu.Lock()
+			files[file.Name] = file
+			links[link.Link] = link
+			mu.Unlock()
+		}(f)
+	}
+
+	wg.Wait()
+
+	if firstErr != nil {
+		return firstErr
+	}
+
+	// Add links to cache
+	r.accounts.SetDownloadLinks(links)
+	t.Files = files
+	return nil
+}
+
+func (r *RealDebrid) CheckLink(link string) error {
+	url := fmt.Sprintf("%s/unrestrict/check", r.Host)
+	payload := gourl.Values{
+		"link": {link},
+	}
+	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
+	resp, err := r.repairClient.Do(req)
+	if err != nil {
+		return err
+	}
+	if resp.StatusCode == http.StatusNotFound {
+		return utils.HosterUnavailableError // File has been removed
+	}
+	return nil
+}
+
+func (r *RealDebrid) _getDownloadLink(file *types.File) (*types.DownloadLink, error) {
+	url := fmt.Sprintf("%s/unrestrict/link/", r.Host)
+	_link := file.Link
+	if strings.HasPrefix(file.Link, "https://real-debrid.com/d/") && len(file.Link) > 39 {
+		_link = file.Link[0:39]
+	}
+	payload := gourl.Values{
+		"link": {_link},
+	}
+	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
+	resp, err := r.downloadClient.Do(req)
+
+	if err != nil {
+		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 nil, err
+		}
+		var data ErrorResponse
+		if err = json.Unmarshal(b, &data); err != nil {
+			return nil, fmt.Errorf("error unmarshalling %d || %s \n %s", resp.StatusCode, err, string(b))
+		}
+		switch data.ErrorCode {
+		case 19:
+			return nil, utils.HosterUnavailableError // File has been removed
+		case 23:
+			return nil, utils.TrafficExceededError
+		case 24:
+			return nil, utils.HosterUnavailableError // Link has been nerfed
+		case 34:
+			return nil, utils.TrafficExceededError // traffic exceeded
+		case 35:
+			return nil, utils.HosterUnavailableError
+		case 36:
+			return nil, utils.TrafficExceededError // traffic exceeded
+		default:
+			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 nil, err
+	}
+	var data UnrestrictResponse
+	if err = json.Unmarshal(b, &data); err != nil {
+		return nil, fmt.Errorf("realdebrid API error: Error unmarshalling response: %w", err)
+	}
+	if data.Download == "" {
+		return nil, fmt.Errorf("realdebrid API error: download link not found")
+	}
+	now := time.Now()
+	return &types.DownloadLink{
+		Filename:     data.Filename,
+		Size:         data.Filesize,
+		Link:         data.Link,
+		DownloadLink: data.Download,
+		Generated:    now,
+		ExpiresAt:    now.Add(r.autoExpiresLinksAfter),
+	}, nil
+
+}
+
+func (r *RealDebrid) GetDownloadLink(t *types.Torrent, file *types.File) (*types.DownloadLink, error) {
+
+	accounts := r.accounts.All()
+
+	for _, account := range accounts {
+		r.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", account.Token))
+		downloadLink, err := r._getDownloadLink(file)
+
+		if err == nil {
+			return downloadLink, nil
+		}
+
+		retries := 0
+		if errors.Is(err, utils.TrafficExceededError) {
+			// Retries generating
+			retries = 5
+		} else {
+			// If the error is not traffic exceeded, return the error
+			return nil, err
+		}
+		backOff := 1 * time.Second
+		for retries > 0 {
+			downloadLink, err = r._getDownloadLink(file)
+			if err == nil {
+				return downloadLink, nil
+			}
+			if !errors.Is(err, utils.TrafficExceededError) {
+				return nil, err
+			}
+			// Add a delay before retrying
+			time.Sleep(backOff)
+			backOff *= 2 // Exponential backoff
+			retries--
+		}
+	}
+	return nil, fmt.Errorf("realdebrid API error: download link not found")
+}
+
+func (r *RealDebrid) getTorrents(offset int, limit int) (int, []*types.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents?limit=%d", r.Host, limit)
+	torrents := make([]*types.Torrent, 0)
+	if offset > 0 {
+		url = fmt.Sprintf("%s&offset=%d", url, offset)
+	}
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := r.client.Do(req)
+
+	if err != nil {
+		return 0, torrents, err
+	}
+
+	if resp.StatusCode == http.StatusNoContent {
+		return 0, torrents, nil
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return 0, torrents, fmt.Errorf("realdebrid API error: %d", resp.StatusCode)
+	}
+
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0, torrents, err
+	}
+	totalItems, _ := strconv.Atoi(resp.Header.Get("X-Total-Count"))
+	var data []TorrentsResponse
+	if err = json.Unmarshal(body, &data); err != nil {
+		return 0, torrents, err
+	}
+	filenames := map[string]struct{}{}
+	for _, t := range data {
+		if t.Status != "downloaded" {
+			continue
+		}
+		torrents = append(torrents, &types.Torrent{
+			Id:               t.Id,
+			Name:             t.Filename,
+			Bytes:            t.Bytes,
+			Progress:         t.Progress,
+			Status:           t.Status,
+			Filename:         t.Filename,
+			OriginalFilename: t.Filename,
+			Links:            t.Links,
+			Files:            make(map[string]types.File),
+			InfoHash:         t.Hash,
+			Debrid:           r.name,
+			MountPath:        r.MountPath,
+			Added:            t.Added.Format(time.RFC3339),
+		})
+		filenames[t.Filename] = struct{}{}
+	}
+	return totalItems, torrents, nil
+}
+
+func (r *RealDebrid) GetTorrents() ([]*types.Torrent, error) {
+	limit := 5000
+
+	// Get first batch and total count
+	allTorrents := make([]*types.Torrent, 0)
+	var fetchError error
+	offset := 0
+	for {
+		// Fetch next batch of torrents
+		_, torrents, err := r.getTorrents(offset, limit)
+		if err != nil {
+			fetchError = err
+			break
+		}
+		totalTorrents := len(torrents)
+		if totalTorrents == 0 {
+			break
+		}
+		allTorrents = append(allTorrents, torrents...)
+		offset += totalTorrents
+	}
+
+	if fetchError != nil {
+		return nil, fetchError
+	}
+
+	return allTorrents, nil
+}
+
+func (r *RealDebrid) GetDownloadLinks() (map[string]*types.DownloadLink, error) {
+	links := make(map[string]*types.DownloadLink)
+	offset := 0
+	limit := 1000
+
+	accounts := r.accounts.All()
+
+	if len(accounts) < 1 {
+		// No active download keys. It's likely that the key has reached bandwidth limit
+		return links, fmt.Errorf("no active download keys")
+	}
+	activeAccount := accounts[0]
+	r.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", activeAccount.Token))
+	for {
+		dl, err := r._getDownloads(offset, limit)
+		if err != nil {
+			break
+		}
+		if len(dl) == 0 {
+			break
+		}
+
+		for _, d := range dl {
+			if _, exists := links[d.Link]; exists {
+				// This is ordered by date, so we can skip the rest
+				continue
+			}
+			links[d.Link] = &d
+		}
+
+		offset += len(dl)
+	}
+
+	return links, nil
+}
+
+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)
+	}
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := r.downloadClient.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var data []DownloadsResponse
+	if err = json.Unmarshal(resp, &data); err != nil {
+		return nil, err
+	}
+	links := make([]types.DownloadLink, 0)
+	for _, d := range data {
+		links = append(links, types.DownloadLink{
+			Filename:     d.Filename,
+			Size:         d.Filesize,
+			Link:         d.Link,
+			DownloadLink: d.Download,
+			Generated:    d.Generated,
+			ExpiresAt:    d.Generated.Add(r.autoExpiresLinksAfter),
+			Id:           d.Id,
+		})
+
+	}
+	return links, nil
+}
+
+func (r *RealDebrid) GetDownloadingStatus() []string {
+	return []string{"downloading", "magnet_conversion", "queued", "compressing", "uploading"}
+}
+
+func (r *RealDebrid) GetDownloadUncached() bool {
+	return r.DownloadUncached
+}
+
+func (r *RealDebrid) GetMountPath() string {
+	return r.MountPath
+}
+
+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
+}
+
+func (r *RealDebrid) GetProfile() (*types.Profile, error) {
+	if r.Profile != nil {
+		return r.Profile, nil
+	}
+	url := fmt.Sprintf("%s/user", r.Host)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+
+	resp, err := r.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var data profileResponse
+	if json.Unmarshal(resp, &data) != nil {
+		return nil, err
+	}
+	profile := &types.Profile{
+		Id:         data.Id,
+		Username:   data.Username,
+		Email:      data.Email,
+		Points:     data.Points,
+		Premium:    data.Premium,
+		Expiration: data.Expiration,
+		Type:       data.Type,
+	}
+	r.Profile = profile
+	return profile, nil
+}
+
+func (r *RealDebrid) GetAvailableSlots() (int, error) {
+	url := fmt.Sprintf("%s/torrents/activeCount", r.Host)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := r.client.MakeRequest(req)
+	if err != nil {
+		return 0, nil
+	}
+	var data AvailableSlotsResponse
+	if json.Unmarshal(resp, &data) != nil {
+		return 0, fmt.Errorf("error unmarshalling available slots response: %w", err)
+	}
+	return data.TotalSlots - data.ActiveSlots - r.minimumFreeSlot, nil // Ensure we maintain minimum active pots
+}
+
+func (r *RealDebrid) Accounts() *types.Accounts {
+	return r.accounts
+}

pkg/debrid/providers/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"`
@@ -139,3 +139,20 @@ type ErrorResponse struct {
 	Error     string `json:"error"`
 	ErrorCode int    `json:"error_code"`
 }
+
+type profileResponse struct {
+	Id         int64     `json:"id"`
+	Username   string    `json:"username"`
+	Email      string    `json:"email"`
+	Points     int64     `json:"points"`
+	Locale     string    `json:"locale"`
+	Avatar     string    `json:"avatar"`
+	Type       string    `json:"type"`
+	Premium    int       `json:"premium"`
+	Expiration time.Time `json:"expiration"`
+}
+
+type AvailableSlotsResponse struct {
+	ActiveSlots int `json:"nb"`
+	TotalSlots  int `json:"limit"`
+}

pkg/debrid/providers/torbox/torbox.go

@@ -2,44 +2,53 @@ 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]
+	name                  string
+	Host                  string `json:"host"`
+	APIKey                string
+	accounts              *types.Accounts
+	autoExpiresLinksAfter time.Duration
+
 	DownloadUncached bool
 	client           *request.Client
 
 	MountPath   string
 	logger      zerolog.Logger
-	CheckCached bool
+	checkCached bool
+	addSamples  bool
 }
 
-func New(dc config.Debrid) *Torbox {
+func (tb *Torbox) GetProfile() (*types.Profile, error) {
+	return nil, nil
+}
+
+func New(dc config.Debrid) (*Torbox, error) {
 	rl := request.ParseRateLimit(dc.RateLimit)
 
 	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(
@@ -48,35 +57,31 @@ func New(dc config.Debrid) *Torbox {
 		request.WithLogger(_log),
 		request.WithProxy(dc.Proxy),
 	)
-
-	accounts := xsync.NewMapOf[string, types.Account]()
-	for idx, key := range dc.DownloadAPIKeys {
-		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
-			Name:  key,
-			ID:    id,
-			Token: key,
-		})
+	autoExpiresLinksAfter, err := time.ParseDuration(dc.AutoExpireLinksAfter)
+	if autoExpiresLinksAfter == 0 || err != nil {
+		autoExpiresLinksAfter = 48 * time.Hour
 	}
 
 	return &Torbox{
-		Name:             "torbox",
-		Host:             dc.Host,
-		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
-		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-		MountPath:        dc.Folder,
-		logger:           _log,
-		CheckCached:      dc.CheckCached,
-	}
+		name:                  "torbox",
+		Host:                  "https://api.torbox.app/v1",
+		APIKey:                dc.APIKey,
+		accounts:              types.NewAccounts(dc),
+		DownloadUncached:      dc.DownloadUncached,
+		autoExpiresLinksAfter: autoExpiresLinksAfter,
+		client:                client,
+		MountPath:             dc.Folder,
+		logger:                _log,
+		checkCached:           dc.CheckCached,
+		addSamples:            dc.AddSamples,
+	}, nil
 }
 
-func (tb *Torbox) GetName() string {
-	return tb.Name
+func (tb *Torbox) Name() string {
+	return tb.name
 }
 
-func (tb *Torbox) GetLogger() zerolog.Logger {
+func (tb *Torbox) Logger() zerolog.Logger {
 	return tb.logger
 }
 
@@ -109,13 +114,13 @@ func (tb *Torbox) IsAvailable(hashes []string) map[string]bool {
 		req, _ := http.NewRequest(http.MethodGet, url, nil)
 		resp, err := tb.client.MakeRequest(req)
 		if err != nil {
-			tb.logger.Info().Msgf("Error checking availability: %v", err)
+			tb.logger.Error().Err(err).Msgf("Error checking availability")
 			return result
 		}
 		var res AvailableResponse
 		err = json.Unmarshal(resp, &res)
 		if err != nil {
-			tb.logger.Info().Msgf("Error marshalling availability: %v", err)
+			tb.logger.Error().Err(err).Msgf("Error marshalling availability")
 			return result
 		}
 		if res.Data == nil {
@@ -158,7 +163,7 @@ func (tb *Torbox) SubmitMagnet(torrent *types.Torrent) (*types.Torrent, error) {
 	torrentId := strconv.Itoa(dt.Id)
 	torrent.Id = torrentId
 	torrent.MountPath = tb.MountPath
-	torrent.Debrid = tb.Name
+	torrent.Debrid = tb.name
 
 	return torrent, nil
 }
@@ -172,13 +177,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)
@@ -203,11 +276,11 @@ func (tb *Torbox) UpdateTorrent(t *types.Torrent) error {
 	t.Filename = name
 	t.OriginalFilename = name
 	t.MountPath = tb.MountPath
-	t.Debrid = tb.Name
+	t.Debrid = tb.name
 	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 +292,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
 	}
@@ -234,11 +308,11 @@ func (tb *Torbox) UpdateTorrent(t *types.Torrent) error {
 	}
 
 	t.OriginalFilename = strings.Split(cleanPath, "/")[0]
-	t.Debrid = tb.Name
+	t.Debrid = tb.name
 	return nil
 }
 
-func (tb *Torbox) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.Torrent, error) {
+func (tb *Torbox) CheckStatus(torrent *types.Torrent) (*types.Torrent, error) {
 	for {
 		err := tb.UpdateTorrent(torrent)
 
@@ -248,14 +322,8 @@ func (tb *Torbox) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.To
 		status := torrent.Status
 		if status == "downloaded" {
 			tb.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			if !isSymlink {
-				err = tb.GenerateDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if slices.Contains(tb.GetDownloadingStatus(), status) {
+			return torrent, nil
+		} else if utils.Contains(tb.GetDownloadingStatus(), status) {
 			if !torrent.DownloadUncached {
 				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
 			}
@@ -267,7 +335,6 @@ func (tb *Torbox) CheckStatus(torrent *types.Torrent, isSymlink bool) (*types.To
 		}
 
 	}
-	return torrent, nil
 }
 
 func (tb *Torbox) DeleteTorrent(torrentId string) error {
@@ -282,8 +349,9 @@ func (tb *Torbox) DeleteTorrent(torrentId string) error {
 	return nil
 }
 
-func (tb *Torbox) GenerateDownloadLinks(t *types.Torrent) error {
+func (tb *Torbox) GetFileDownloadLinks(t *types.Torrent) error {
 	filesCh := make(chan types.File, len(t.Files))
+	linkCh := make(chan *types.DownloadLink)
 	errCh := make(chan error, len(t.Files))
 
 	var wg sync.WaitGroup
@@ -291,19 +359,22 @@ 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
+			if link != nil {
+				linkCh <- link
+				file.DownloadLink = link
+			}
 			filesCh <- file
 		}()
 	}
 	go func() {
 		wg.Wait()
 		close(filesCh)
+		close(linkCh)
 		close(errCh)
 	}()
 
@@ -313,6 +384,13 @@ func (tb *Torbox) GenerateDownloadLinks(t *types.Torrent) error {
 		files[file.Name] = file
 	}
 
+	// Collect download links
+	for link := range linkCh {
+		if link != nil {
+			tb.accounts.SetDownloadLink(link.Link, link)
+		}
+	}
+
 	// Check for errors
 	for err := range errCh {
 		if err != nil {
@@ -324,7 +402,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,27 +412,33 @@ 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")
+	}
+	now := time.Now()
+	return &types.DownloadLink{
+		Link:         file.Link,
+		DownloadLink: link,
+		Id:           file.Id,
+		Generated:    now,
+		ExpiresAt:    now.Add(tb.autoExpiresLinksAfter),
+	}, nil
 }
 
 func (tb *Torbox) GetDownloadingStatus() []string {
 	return []string{"downloading"}
 }
 
-func (tb *Torbox) GetCheckCached() bool {
-	return tb.CheckCached
-}
-
 func (tb *Torbox) GetTorrents() ([]*types.Torrent, error) {
 	return nil, nil
 }
@@ -363,7 +447,7 @@ func (tb *Torbox) GetDownloadUncached() bool {
 	return tb.DownloadUncached
 }
 
-func (tb *Torbox) GetDownloads() (map[string]types.DownloadLinks, error) {
+func (tb *Torbox) GetDownloadLinks() (map[string]*types.DownloadLink, error) {
 	return nil, nil
 }
 
@@ -375,9 +459,15 @@ func (tb *Torbox) GetMountPath() string {
 	return tb.MountPath
 }
 
-func (tb *Torbox) DisableAccount(accountId string) {
+func (tb *Torbox) DeleteDownloadLink(linkId string) error {
+	return nil
 }
 
-func (tb *Torbox) ResetActiveDownloadKeys() {
-
+func (tb *Torbox) GetAvailableSlots() (int, error) {
+	//TODO: Implement the logic to check available slots for Torbox
+	return 0, fmt.Errorf("not implemented")
+}
+
+func (tb *Torbox) Accounts() *types.Accounts {
+	return tb.accounts
 }

pkg/debrid/realdebrid/realdebrid.go

@@ -1,728 +0,0 @@
-package realdebrid
-
-import (
-	"bytes"
-	"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"
-	"github.com/sirrobot01/decypharr/internal/request"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"io"
-	"net/http"
-	gourl "net/url"
-	"path/filepath"
-	"slices"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-type RealDebrid struct {
-	Name string
-	Host string `json:"host"`
-
-	APIKey       string
-	DownloadKeys *xsync.MapOf[string, types.Account] // index | Account
-
-	DownloadUncached bool
-	client           *request.Client
-	downloadClient   *request.Client
-
-	MountPath   string
-	logger      zerolog.Logger
-	CheckCached bool
-}
-
-func New(dc config.Debrid) *RealDebrid {
-	rl := request.ParseRateLimit(dc.RateLimit)
-
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-	}
-	_log := logger.New(dc.Name)
-
-	accounts := xsync.NewMapOf[string, types.Account]()
-	firstDownloadKey := dc.DownloadAPIKeys[0]
-	for idx, key := range dc.DownloadAPIKeys {
-		id := strconv.Itoa(idx)
-		accounts.Store(id, types.Account{
-			Name:  key,
-			ID:    id,
-			Token: key,
-		})
-	}
-
-	downloadHeaders := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", firstDownloadKey),
-	}
-
-	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,
-		APIKey:           dc.APIKey,
-		DownloadKeys:     accounts,
-		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-		downloadClient:   downloadClient,
-		MountPath:        dc.Folder,
-		logger:           logger.New(dc.Name),
-		CheckCached:      dc.CheckCached,
-	}
-}
-
-func (r *RealDebrid) GetName() string {
-	return r.Name
-}
-
-func (r *RealDebrid) GetLogger() zerolog.Logger {
-	return r.logger
-}
-
-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),
-			}
-			selectedFiles = append(selectedFiles, file)
-		}
-	}
-	files := make(map[string]types.File)
-	for index, f := range selectedFiles {
-		if index >= len(data.Links) {
-			break
-		}
-		f.Link = data.Links[index]
-		files[f.Name] = f
-	}
-	return files
-}
-
-// 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 {
-	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) {
-			// Skip sample files
-			continue
-		}
-
-		if !cfg.IsAllowedFile(name) {
-			continue
-		}
-		if !cfg.IsSizeAllowed(f.Bytes) {
-			continue
-		}
-
-		file := types.File{
-			Name: name,
-			Path: name,
-			Size: f.Bytes,
-			Id:   strconv.Itoa(f.ID),
-		}
-		files[name] = file
-		idx++
-	}
-	return files
-}
-
-func (r *RealDebrid) IsAvailable(hashes []string) map[string]bool {
-	// Check if the infohashes are available in the local cache
-	result := make(map[string]bool)
-
-	// Divide hashes into groups of 100
-	for i := 0; i < len(hashes); i += 200 {
-		end := i + 200
-		if end > len(hashes) {
-			end = len(hashes)
-		}
-
-		// Filter out empty strings
-		validHashes := make([]string, 0, end-i)
-		for _, hash := range hashes[i:end] {
-			if hash != "" {
-				validHashes = append(validHashes, hash)
-			}
-		}
-
-		// If no valid hashes in this batch, continue to the next batch
-		if len(validHashes) == 0 {
-			continue
-		}
-
-		hashStr := strings.Join(validHashes, "/")
-		url := fmt.Sprintf("%s/torrents/instantAvailability/%s", r.Host, hashStr)
-		req, _ := http.NewRequest(http.MethodGet, url, nil)
-		resp, err := r.client.MakeRequest(req)
-		if err != nil {
-			r.logger.Info().Msgf("Error checking availability: %v", err)
-			return result
-		}
-		var data AvailabilityResponse
-		err = json.Unmarshal(resp, &data)
-		if err != nil {
-			r.logger.Info().Msgf("Error marshalling availability: %v", err)
-			return result
-		}
-		for _, h := range hashes[i:end] {
-			hosters, exists := data[strings.ToLower(h)]
-			if exists && len(hosters.Rd) > 0 {
-				result[h] = true
-			}
-		}
-	}
-	return result
-}
-
-func (r *RealDebrid) SubmitMagnet(t *types.Torrent) (*types.Torrent, error) {
-	if t.Magnet.IsTorrent() {
-		return r.addTorrent(t)
-	}
-	return r.addMagnet(t)
-}
-
-func (r *RealDebrid) addTorrent(t *types.Torrent) (*types.Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/addTorrent", r.Host)
-	var data AddMagnetSchema
-	req, err := http.NewRequest(http.MethodPut, url, bytes.NewReader(t.Magnet.File))
-
-	if err != nil {
-		return nil, err
-	}
-	req.Header.Add("Content-Type", "application/x-bittorrent")
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	if err = json.Unmarshal(resp, &data); err != nil {
-		return nil, err
-	}
-	t.Id = data.Id
-	t.Debrid = r.Name
-	t.MountPath = r.MountPath
-	return t, nil
-}
-
-func (r *RealDebrid) addMagnet(t *types.Torrent) (*types.Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/addMagnet", r.Host)
-	payload := gourl.Values{
-		"magnet": {t.Magnet.Link},
-	}
-	var data AddMagnetSchema
-	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	if err = json.Unmarshal(resp, &data); err != nil {
-		return nil, err
-	}
-	t.Id = data.Id
-	t.Debrid = r.Name
-	t.MountPath = r.MountPath
-	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)
-	if err != nil {
-		return err
-	}
-	var data TorrentInfo
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return err
-	}
-	t.Name = data.Filename
-	t.Bytes = data.Bytes
-	t.Folder = data.OriginalFilename
-	t.Progress = data.Progress
-	t.Status = data.Status
-	t.Speed = data.Speed
-	t.Seeders = data.Seeders
-	t.Filename = data.Filename
-	t.OriginalFilename = data.OriginalFilename
-	t.Links = data.Links
-	t.MountPath = r.MountPath
-	t.Debrid = r.Name
-	t.Added = data.Added
-	t.Files = getSelectedFiles(t, data) // Get selected files
-	return nil
-}
-
-func (r *RealDebrid) CheckStatus(t *types.Torrent, isSymlink bool) (*types.Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, t.Id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	for {
-		resp, err := r.client.MakeRequest(req)
-		if err != nil {
-			r.logger.Info().Msgf("ERROR Checking file: %v", err)
-			return t, err
-		}
-		var data TorrentInfo
-		if err = json.Unmarshal(resp, &data); err != nil {
-			return t, err
-		}
-		status := data.Status
-		t.Name = data.Filename // Important because some magnet changes the name
-		t.Folder = data.OriginalFilename
-		t.Filename = data.Filename
-		t.OriginalFilename = data.OriginalFilename
-		t.Bytes = data.Bytes
-		t.Progress = data.Progress
-		t.Speed = data.Speed
-		t.Seeders = data.Seeders
-		t.Links = data.Links
-		t.Status = status
-		t.Debrid = r.Name
-		t.MountPath = r.MountPath
-		if status == "waiting_files_selection" {
-			t.Files = getTorrentFiles(t, data)
-			if len(t.Files) == 0 {
-				return t, fmt.Errorf("no video files found")
-			}
-			filesId := make([]string, 0)
-			for _, f := range t.Files {
-				filesId = append(filesId, f.Id)
-			}
-			p := gourl.Values{
-				"files": {strings.Join(filesId, ",")},
-			}
-			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)
-			if err != nil {
-				return t, err
-			}
-		} else if status == "downloaded" {
-			t.Files = getSelectedFiles(t, data) // Get selected files
-			r.logger.Info().Msgf("Torrent: %s downloaded to RD", t.Name)
-			if !isSymlink {
-				err = r.GenerateDownloadLinks(t)
-				if err != nil {
-					return t, err
-				}
-			}
-			break
-		} else if slices.Contains(r.GetDownloadingStatus(), status) {
-			if !t.DownloadUncached {
-				return t, fmt.Errorf("torrent: %s not cached", t.Name)
-			}
-			return t, nil
-		} else {
-			return t, fmt.Errorf("torrent: %s has error: %s", t.Name, status)
-		}
-
-	}
-	return t, nil
-}
-
-func (r *RealDebrid) DeleteTorrent(torrentId string) error {
-	url := fmt.Sprintf("%s/torrents/delete/%s", r.Host, torrentId)
-	req, _ := http.NewRequest(http.MethodDelete, url, nil)
-	if _, err := r.client.MakeRequest(req); err != nil {
-		return err
-	}
-	r.logger.Info().Msgf("Torrent: %s deleted from RD", torrentId)
-	return nil
-}
-
-func (r *RealDebrid) GenerateDownloadLinks(t *types.Torrent) error {
-	filesCh := make(chan types.File, len(t.Files))
-	errCh := make(chan error, len(t.Files))
-
-	var wg sync.WaitGroup
-	wg.Add(len(t.Files))
-	for _, f := range t.Files {
-		go func(file types.File) {
-			defer wg.Done()
-
-			link, accountId, err := r.GetDownloadLink(t, &file)
-			if err != nil {
-				errCh <- err
-				return
-			}
-
-			file.DownloadLink = link
-			file.AccountId = accountId
-			filesCh <- file
-		}(f)
-	}
-
-	go func() {
-		wg.Wait()
-		close(filesCh)
-		close(errCh)
-	}()
-
-	// Collect results
-	files := make(map[string]types.File, len(t.Files))
-	for file := range filesCh {
-		files[file.Name] = file
-	}
-
-	// Check for errors
-	for err := range errCh {
-		if err != nil {
-			return err // Return the first error encountered
-		}
-	}
-
-	t.Files = files
-	return nil
-}
-
-func (r *RealDebrid) CheckLink(link string) error {
-	url := fmt.Sprintf("%s/unrestrict/check", r.Host)
-	payload := gourl.Values{
-		"link": {link},
-	}
-	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
-	resp, err := r.client.Do(req)
-	if err != nil {
-		return err
-	}
-	if resp.StatusCode == http.StatusNotFound {
-		return request.HosterUnavailableError // File has been removed
-	}
-	return nil
-}
-
-func (r *RealDebrid) _getDownloadLink(file *types.File) (string, 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
-	}
-	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
-		}
-		var data ErrorResponse
-		if err = json.Unmarshal(b, &data); err != nil {
-			return "", err
-		}
-		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
-		case 34:
-			return "", request.TrafficExceededError // traffic exceeded
-		default:
-			return "", fmt.Errorf("realdebrid API error: Status: %d || Code: %d", resp.StatusCode, data.ErrorCode)
-		}
-	}
-	b, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return "", err
-	}
-	var data UnrestrictResponse
-	if err = json.Unmarshal(b, &data); err != nil {
-		return "", err
-	}
-	return data.Download, 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
-		}
-
-	}
-	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
-	if err != nil {
-		if errors.Is(err, request.TrafficExceededError) {
-			return "", "", request.TrafficExceededError
-		}
-		return "", "", fmt.Errorf("error generating download link: %v", err)
-	}
-	return "", "", fmt.Errorf("error generating download link: %v", err)
-}
-
-func (r *RealDebrid) GetCheckCached() bool {
-	return r.CheckCached
-}
-
-func (r *RealDebrid) getTorrents(offset int, limit int) (int, []*types.Torrent, error) {
-	url := fmt.Sprintf("%s/torrents?limit=%d", r.Host, limit)
-	torrents := make([]*types.Torrent, 0)
-	if offset > 0 {
-		url = fmt.Sprintf("%s&offset=%d", url, offset)
-	}
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.Do(req)
-
-	if err != nil {
-		return 0, torrents, err
-	}
-
-	if resp.StatusCode == http.StatusNoContent {
-		return 0, torrents, nil
-	}
-
-	if resp.StatusCode != http.StatusOK {
-		resp.Body.Close()
-		return 0, torrents, fmt.Errorf("realdebrid API error: %d", resp.StatusCode)
-	}
-
-	defer resp.Body.Close()
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return 0, torrents, err
-	}
-	totalItems, _ := strconv.Atoi(resp.Header.Get("X-Total-Count"))
-	var data []TorrentsResponse
-	if err = json.Unmarshal(body, &data); err != nil {
-		return 0, nil, 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,
-			Bytes:            t.Bytes,
-			Progress:         t.Progress,
-			Status:           t.Status,
-			Filename:         t.Filename,
-			OriginalFilename: t.Filename,
-			Links:            t.Links,
-			Files:            make(map[string]types.File),
-			InfoHash:         t.Hash,
-			Debrid:           r.Name,
-			MountPath:        r.MountPath,
-			Added:            t.Added.Format(time.RFC3339),
-		})
-		filenames[t.Filename] = struct{}{}
-	}
-	return totalItems, torrents, nil
-}
-
-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
-	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)
-		if err != nil {
-			fetchError = err
-			continue
-		}
-		allTorrents = append(allTorrents, batch...)
-	}
-
-	if fetchError != nil {
-		return nil, fetchError
-	}
-
-	return allTorrents, nil
-}
-
-func (r *RealDebrid) GetDownloads() (map[string]types.DownloadLinks, error) {
-	links := make(map[string]types.DownloadLinks)
-	offset := 0
-	limit := 1000
-
-	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.downloadClient.SetHeader("Authorization", fmt.Sprintf("Bearer %s", accounts[0].Token))
-	for {
-		dl, err := r._getDownloads(offset, limit)
-		if err != nil {
-			break
-		}
-		if len(dl) == 0 {
-			break
-		}
-
-		for _, d := range dl {
-			if _, exists := links[d.Link]; exists {
-				// This is ordered by date, so we can skip the rest
-				continue
-			}
-			links[d.Link] = d
-		}
-
-		offset += len(dl)
-	}
-	return links, nil
-}
-
-func (r *RealDebrid) _getDownloads(offset int, limit int) ([]types.DownloadLinks, error) {
-	url := fmt.Sprintf("%s/downloads?limit=%d", r.Host, limit)
-	if offset > 0 {
-		url = fmt.Sprintf("%s&offset=%d", url, offset)
-	}
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.downloadClient.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	var data []DownloadsResponse
-	if err = json.Unmarshal(resp, &data); err != nil {
-		return nil, err
-	}
-	links := make([]types.DownloadLinks, 0)
-	for _, d := range data {
-		links = append(links, types.DownloadLinks{
-			Filename:     d.Filename,
-			Size:         d.Filesize,
-			Link:         d.Link,
-			DownloadLink: d.Download,
-			Generated:    d.Generated,
-			Id:           d.Id,
-		})
-
-	}
-	return links, nil
-}
-
-func (r *RealDebrid) GetDownloadingStatus() []string {
-	return []string{"downloading", "magnet_conversion", "queued", "compressing", "uploading"}
-}
-
-func (r *RealDebrid) GetDownloadUncached() bool {
-	return r.DownloadUncached
-}
-
-func (r *RealDebrid) GetMountPath() string {
-	return r.MountPath
-}
-
-func (r *RealDebrid) DisableAccount(accountId string) {
-	if value, ok := r.DownloadKeys.Load(accountId); ok {
-		value.Disabled = true
-		r.DownloadKeys.Store(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 {
-		value.Disabled = false
-		r.DownloadKeys.Store(key, value)
-		return true
-	})
-}
-
-func (r *RealDebrid) getActiveAccounts() []types.Account {
-	accounts := make([]types.Account, 0)
-	r.DownloadKeys.Range(func(key string, value types.Account) bool {
-		if value.Disabled {
-			return true
-		}
-		accounts = append(accounts, value)
-		return true
-	})
-	sort.Slice(accounts, func(i, j int) bool {
-		return accounts[i].ID < accounts[j].ID
-	})
-	return accounts
-}

pkg/debrid/store/cache.go

@@ -0,0 +1,876 @@
+package store
+
+import (
+	"bufio"
+	"cmp"
+	"context"
+	"errors"
+	"fmt"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"os"
+	"path"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"encoding/json"
+	"github.com/go-co-op/gocron/v2"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/decypharr/internal/config"
+	"github.com/sirrobot01/decypharr/internal/logger"
+	"github.com/sirrobot01/decypharr/internal/utils"
+	_ "time/tzdata"
+)
+
+type WebDavFolderNaming string
+
+const (
+	WebDavUseFileName          WebDavFolderNaming = "filename"
+	WebDavUseOriginalName      WebDavFolderNaming = "original"
+	WebDavUseFileNameNoExt     WebDavFolderNaming = "filename_no_ext"
+	WebDavUseOriginalNameNoExt WebDavFolderNaming = "original_no_ext"
+	WebDavUseID                WebDavFolderNaming = "id"
+	WebdavUseHash              WebDavFolderNaming = "infohash"
+)
+
+type CachedTorrent struct {
+	*types.Torrent
+	AddedOn    time.Time `json:"added_on"`
+	IsComplete bool      `json:"is_complete"`
+	Bad        bool      `json:"bad"`
+}
+
+func (c CachedTorrent) copy() CachedTorrent {
+	return CachedTorrent{
+		Torrent:    c.Torrent,
+		AddedOn:    c.AddedOn,
+		IsComplete: c.IsComplete,
+		Bad:        c.Bad,
+	}
+}
+
+type RepairType string
+
+const (
+	RepairTypeReinsert RepairType = "reinsert"
+	RepairTypeDelete   RepairType = "delete"
+)
+
+type RepairRequest struct {
+	Type      RepairType
+	TorrentID string
+	Priority  int
+	FileName  string
+}
+
+type Cache struct {
+	dir    string
+	client types.Client
+	logger zerolog.Logger
+
+	torrents             *torrentCache
+	invalidDownloadLinks sync.Map
+	folderNaming         WebDavFolderNaming
+
+	listingDebouncer *utils.Debouncer[bool]
+	// monitors
+	repairRequest        sync.Map
+	failedToReinsert     sync.Map
+	downloadLinkRequests sync.Map
+
+	// repair
+	repairChan chan RepairRequest
+
+	// readiness
+	ready chan struct{}
+
+	// config
+	workers                      int
+	torrentRefreshInterval       string
+	downloadLinksRefreshInterval string
+
+	// refresh mutex
+	downloadLinksRefreshMu sync.RWMutex // for refreshing download links
+	torrentsRefreshMu      sync.RWMutex // for refreshing torrents
+
+	scheduler    gocron.Scheduler
+	cetScheduler gocron.Scheduler
+
+	saveSemaphore chan struct{}
+
+	config        config.Debrid
+	customFolders []string
+}
+
+func NewDebridCache(dc config.Debrid, client types.Client) *Cache {
+	cfg := config.Get()
+	cet, err := time.LoadLocation("CET")
+	if err != nil {
+		cet, err = time.LoadLocation("Europe/Berlin") // Fallback to Berlin if CET fails
+		if err != nil {
+			cet = time.FixedZone("CET", 1*60*60) // Fallback to a fixed CET zone
+		}
+	}
+	cetSc, err := gocron.NewScheduler(gocron.WithLocation(cet))
+	if err != nil {
+		// If we can't create a CET scheduler, fallback to local time
+		cetSc, _ = gocron.NewScheduler(gocron.WithLocation(time.Local))
+	}
+	scheduler, err := gocron.NewScheduler(gocron.WithLocation(time.Local))
+	if err != nil {
+		// If we can't create a local scheduler, fallback to CET
+		scheduler = cetSc
+	}
+
+	var customFolders []string
+	dirFilters := map[string][]directoryFilter{}
+	for name, value := range dc.Directories {
+		for filterType, v := range value.Filters {
+			df := directoryFilter{filterType: filterType, value: v}
+			switch filterType {
+			case filterByRegex, filterByNotRegex:
+				df.regex = regexp.MustCompile(v)
+			case filterBySizeGT, filterBySizeLT:
+				df.sizeThreshold, _ = config.ParseSize(v)
+			case filterBLastAdded:
+				df.ageThreshold, _ = time.ParseDuration(v)
+			}
+			dirFilters[name] = append(dirFilters[name], df)
+		}
+		customFolders = append(customFolders, name)
+
+	}
+	_log := logger.New(fmt.Sprintf("%s-webdav", client.Name()))
+	c := &Cache{
+		dir: filepath.Join(cfg.Path, "cache", dc.Name), // path to save cache files
+
+		torrents:                     newTorrentCache(dirFilters),
+		client:                       client,
+		logger:                       _log,
+		workers:                      dc.Workers,
+		torrentRefreshInterval:       dc.TorrentsRefreshInterval,
+		downloadLinksRefreshInterval: dc.DownloadLinksRefreshInterval,
+		folderNaming:                 WebDavFolderNaming(dc.FolderNaming),
+		saveSemaphore:                make(chan struct{}, 50),
+		cetScheduler:                 cetSc,
+		scheduler:                    scheduler,
+
+		config:        dc,
+		customFolders: customFolders,
+
+		ready: make(chan struct{}),
+	}
+
+	c.listingDebouncer = utils.NewDebouncer[bool](100*time.Millisecond, func(refreshRclone bool) {
+		c.RefreshListings(refreshRclone)
+	})
+	return c
+}
+
+func (c *Cache) IsReady() chan struct{} {
+	return c.ready
+}
+
+func (c *Cache) StreamWithRclone() bool {
+	return c.config.ServeFromRclone
+}
+
+// Reset clears all internal state so the Cache can be reused without leaks.
+// Call this after stopping the old Cache (so no goroutines are holding references),
+// and before you discard the instance on a restart.
+func (c *Cache) Reset() {
+
+	if err := c.scheduler.StopJobs(); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to stop scheduler jobs")
+	}
+
+	if err := c.scheduler.Shutdown(); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to stop scheduler")
+	}
+
+	// Stop the listing debouncer
+	c.listingDebouncer.Stop()
+
+	// Close the repair channel
+	close(c.repairChan)
+
+	// 1. Reset torrent storage
+	c.torrents.reset()
+
+	// 3. Clear any sync.Maps
+	c.invalidDownloadLinks = sync.Map{}
+	c.repairRequest = sync.Map{}
+	c.failedToReinsert = sync.Map{}
+	c.downloadLinkRequests = sync.Map{}
+
+	// 5. Rebuild the listing debouncer
+	c.listingDebouncer = utils.NewDebouncer[bool](
+		100*time.Millisecond,
+		func(refreshRclone bool) {
+			c.RefreshListings(refreshRclone)
+		},
+	)
+
+	// 6. Reset repair channel so the next Start() can spin it up
+	c.repairChan = make(chan RepairRequest, 100)
+}
+
+func (c *Cache) Start(ctx context.Context) error {
+	if err := os.MkdirAll(c.dir, 0755); err != nil {
+		return fmt.Errorf("failed to create cache directory: %w", err)
+	}
+
+	c.logger.Info().Msgf("Started indexing...")
+
+	if err := c.Sync(ctx); err != nil {
+		return fmt.Errorf("failed to sync cache: %w", err)
+	}
+	// Fire the ready channel
+	close(c.ready)
+	c.logger.Info().Msgf("Indexing complete, %d torrents loaded", len(c.torrents.getAll()))
+
+	// initial download links
+	go c.refreshDownloadLinks(ctx)
+
+	if err := c.StartSchedule(ctx); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to start cache worker")
+	}
+
+	c.repairChan = make(chan RepairRequest, 100) // Initialize the repair channel, max 100 requests buffered
+	go c.repairWorker(ctx)
+
+	cfg := config.Get()
+	name := c.client.Name()
+	addr := cfg.BindAddress + ":" + cfg.Port + cfg.URLBase + "webdav/" + name + "/"
+	c.logger.Info().Msgf("%s WebDav server running at %s", name, addr)
+
+	<-ctx.Done()
+	c.logger.Info().Msgf("Stopping %s WebDav server", name)
+	c.Reset()
+
+	return nil
+}
+
+func (c *Cache) load(ctx context.Context) (map[string]CachedTorrent, error) {
+	mu := sync.Mutex{}
+
+	if err := os.MkdirAll(c.dir, 0755); err != nil {
+		return nil, fmt.Errorf("failed to create cache directory: %w", err)
+	}
+
+	files, err := os.ReadDir(c.dir)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read cache directory: %w", err)
+	}
+
+	// Get only json files
+	var jsonFiles []os.DirEntry
+	for _, file := range files {
+		if !file.IsDir() && filepath.Ext(file.Name()) == ".json" {
+			jsonFiles = append(jsonFiles, file)
+		}
+	}
+
+	if len(jsonFiles) == 0 {
+		return nil, nil
+	}
+
+	// Create channels with appropriate buffering
+	workChan := make(chan os.DirEntry, min(c.workers, len(jsonFiles)))
+
+	// Create a wait group for workers
+	var wg sync.WaitGroup
+
+	torrents := make(map[string]CachedTorrent, len(jsonFiles))
+
+	// Start workers
+	for i := 0; i < c.workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+
+			for {
+				file, ok := <-workChan
+				if !ok {
+					return // Channel closed, exit goroutine
+				}
+
+				fileName := file.Name()
+				filePath := filepath.Join(c.dir, fileName)
+				data, err := os.ReadFile(filePath)
+				if err != nil {
+					c.logger.Error().Err(err).Msgf("Failed to read file: %s", filePath)
+					continue
+				}
+
+				var ct CachedTorrent
+				if err := json.Unmarshal(data, &ct); err != nil {
+					c.logger.Error().Err(err).Msgf("Failed to unmarshal file: %s", filePath)
+					continue
+				}
+
+				isComplete := true
+				if len(ct.GetFiles()) != 0 {
+					// Check if all files are valid, if not, delete the file.json and remove from cache.
+					fs := make(map[string]types.File, len(ct.GetFiles()))
+					for _, f := range ct.GetFiles() {
+						if f.Link == "" {
+							isComplete = false
+							break
+						}
+						f.TorrentId = ct.Id
+						fs[f.Name] = f
+					}
+
+					if isComplete {
+
+						if addedOn, err := time.Parse(time.RFC3339, ct.Added); err == nil {
+							ct.AddedOn = addedOn
+						}
+						ct.IsComplete = true
+						ct.Files = fs
+						ct.Name = path.Clean(ct.Name)
+						mu.Lock()
+						torrents[ct.Id] = ct
+						mu.Unlock()
+					}
+				}
+			}
+		}()
+	}
+
+	// Feed work to workers
+	for _, file := range jsonFiles {
+		select {
+		case <-ctx.Done():
+			break // Context cancelled
+		default:
+			workChan <- file
+		}
+	}
+
+	// Signal workers that no more work is coming
+	close(workChan)
+
+	// Wait for all workers to complete
+	wg.Wait()
+
+	return torrents, nil
+}
+
+func (c *Cache) Sync(ctx context.Context) error {
+	cachedTorrents, err := c.load(ctx)
+	if err != nil {
+		c.logger.Error().Err(err).Msg("Failed to load cache")
+	}
+
+	torrents, err := c.client.GetTorrents()
+	if err != nil {
+		return fmt.Errorf("failed to sync torrents: %v", err)
+	}
+
+	totalTorrents := len(torrents)
+
+	c.logger.Info().Msgf("%d torrents found from %s", totalTorrents, c.client.Name())
+
+	newTorrents := make([]*types.Torrent, 0)
+	idStore := make(map[string]struct{}, totalTorrents)
+	for _, t := range torrents {
+		idStore[t.Id] = struct{}{}
+		if _, ok := cachedTorrents[t.Id]; !ok {
+			newTorrents = append(newTorrents, t)
+		}
+	}
+
+	// Check for deleted torrents
+	deletedTorrents := make([]string, 0)
+	for _, t := range cachedTorrents {
+		if _, ok := idStore[t.Id]; !ok {
+			deletedTorrents = append(deletedTorrents, t.Id)
+		}
+	}
+
+	if len(deletedTorrents) > 0 {
+		c.logger.Info().Msgf("Found %d deleted torrents", len(deletedTorrents))
+		for _, id := range deletedTorrents {
+			// Remove from cache and debrid service
+			delete(cachedTorrents, id)
+			// Remove the json file from disk
+			c.removeFile(id, false)
+
+		}
+	}
+
+	// Write these torrents to the cache
+	c.setTorrents(cachedTorrents, func() {
+		c.listingDebouncer.Call(false)
+	}) // Initial calls
+	c.logger.Info().Msgf("Loaded %d torrents from cache", len(cachedTorrents))
+
+	if len(newTorrents) > 0 {
+		c.logger.Info().Msgf("Found %d new torrents", len(newTorrents))
+		if err := c.sync(ctx, newTorrents); err != nil {
+			return fmt.Errorf("failed to sync torrents: %v", err)
+		}
+	}
+
+	return nil
+}
+
+func (c *Cache) sync(ctx context.Context, torrents []*types.Torrent) error {
+
+	// Create channels with appropriate buffering
+	workChan := make(chan *types.Torrent, min(c.workers, len(torrents)))
+
+	// Use an atomic counter for progress tracking
+	var processed int64
+	var errorCount int64
+
+	// Create a wait group for workers
+	var wg sync.WaitGroup
+
+	// Start workers
+	for i := 0; i < c.workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for {
+				select {
+				case t, ok := <-workChan:
+					if !ok {
+						return // Channel closed, exit goroutine
+					}
+
+					if err := c.ProcessTorrent(t); err != nil {
+						c.logger.Error().Err(err).Str("torrent", t.Name).Msg("sync error")
+						atomic.AddInt64(&errorCount, 1)
+					}
+
+					count := atomic.AddInt64(&processed, 1)
+					if count%1000 == 0 {
+						c.logger.Info().Msgf("Progress: %d/%d torrents processed", count, len(torrents))
+					}
+
+				case <-ctx.Done():
+					return // Context cancelled, exit goroutine
+				}
+			}
+		}()
+	}
+
+	// Feed work to workers
+	for _, t := range torrents {
+		select {
+		case workChan <- t:
+			// Work sent successfully
+		case <-ctx.Done():
+			break // Context cancelled
+		}
+	}
+
+	// Signal workers that no more work is coming
+	close(workChan)
+
+	// Wait for all workers to complete
+	wg.Wait()
+
+	c.listingDebouncer.Call(false) // final refresh
+	c.logger.Info().Msgf("Sync complete: %d torrents processed, %d errors", len(torrents), errorCount)
+	return nil
+}
+
+func (c *Cache) GetTorrentFolder(torrent *types.Torrent) string {
+	switch c.folderNaming {
+	case WebDavUseFileName:
+		return path.Clean(torrent.Filename)
+	case WebDavUseOriginalName:
+		return path.Clean(torrent.OriginalFilename)
+	case WebDavUseFileNameNoExt:
+		return path.Clean(utils.RemoveExtension(torrent.Filename))
+	case WebDavUseOriginalNameNoExt:
+		return path.Clean(utils.RemoveExtension(torrent.OriginalFilename))
+	case WebDavUseID:
+		return torrent.Id
+	case WebdavUseHash:
+		return strings.ToLower(torrent.InfoHash)
+	default:
+		return path.Clean(torrent.Filename)
+	}
+}
+
+func (c *Cache) setTorrent(t CachedTorrent, callback func(torrent CachedTorrent)) {
+	torrentName := c.GetTorrentFolder(t.Torrent)
+	updatedTorrent := t.copy()
+	if o, ok := c.torrents.getByName(torrentName); ok && o.Id != t.Id {
+		// If another torrent with the same name exists, merge the files, if the same file exists,
+		// keep the one with the most recent added date
+
+		// Save the most recent torrent
+		mergedFiles := mergeFiles(o, updatedTorrent) // Useful for merging files across multiple torrents, while keeping the most recent
+		updatedTorrent.Files = mergedFiles
+	}
+	c.torrents.set(torrentName, t, updatedTorrent)
+	go c.SaveTorrent(t)
+	if callback != nil {
+		go callback(updatedTorrent)
+	}
+}
+
+func (c *Cache) setTorrents(torrents map[string]CachedTorrent, callback func()) {
+	for _, t := range torrents {
+		torrentName := c.GetTorrentFolder(t.Torrent)
+		updatedTorrent := t.copy()
+		if o, ok := c.torrents.getByName(torrentName); ok && o.Id != t.Id {
+			// Save the most recent torrent
+			mergedFiles := mergeFiles(o, updatedTorrent)
+			updatedTorrent.Files = mergedFiles
+		}
+		c.torrents.set(torrentName, t, updatedTorrent)
+	}
+	c.SaveTorrents()
+	if callback != nil {
+		callback()
+	}
+}
+
+// GetListing returns a sorted list of torrents(READ-ONLY)
+func (c *Cache) GetListing(folder string) []os.FileInfo {
+	switch folder {
+	case "__all__", "torrents":
+		return c.torrents.getListing()
+	default:
+		return c.torrents.getFolderListing(folder)
+	}
+}
+
+func (c *Cache) GetCustomFolders() []string {
+	return c.customFolders
+}
+
+func (c *Cache) Close() error {
+	return nil
+}
+
+func (c *Cache) GetTorrents() map[string]CachedTorrent {
+	return c.torrents.getAll()
+}
+
+func (c *Cache) TotalTorrents() int {
+	return c.torrents.getAllCount()
+}
+
+func (c *Cache) GetTorrentByName(name string) *CachedTorrent {
+	if torrent, ok := c.torrents.getByName(name); ok {
+		return &torrent
+	}
+	return nil
+}
+
+func (c *Cache) GetTorrentsName() map[string]CachedTorrent {
+	return c.torrents.getAllByName()
+}
+
+func (c *Cache) GetTorrent(torrentId string) *CachedTorrent {
+	if torrent, ok := c.torrents.getByID(torrentId); ok {
+		return &torrent
+	}
+	return nil
+}
+
+func (c *Cache) SaveTorrents() {
+	torrents := c.torrents.getAll()
+	for _, torrent := range torrents {
+		c.SaveTorrent(torrent)
+	}
+}
+
+func (c *Cache) SaveTorrent(ct CachedTorrent) {
+	marshaled, err := json.MarshalIndent(ct, "", "  ")
+	if err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to marshal torrent: %s", ct.Id)
+		return
+	}
+
+	// Store just the essential info needed for the file operation
+	saveInfo := struct {
+		id       string
+		jsonData []byte
+	}{
+		id:       ct.Torrent.Id,
+		jsonData: marshaled,
+	}
+
+	// Try to acquire semaphore without blocking
+	select {
+	case c.saveSemaphore <- struct{}{}:
+		go func() {
+			defer func() { <-c.saveSemaphore }()
+			c.saveTorrent(saveInfo.id, saveInfo.jsonData)
+		}()
+	default:
+		c.saveTorrent(saveInfo.id, saveInfo.jsonData)
+	}
+}
+
+func (c *Cache) saveTorrent(id string, data []byte) {
+
+	fileName := id + ".json"
+	filePath := filepath.Join(c.dir, fileName)
+
+	// Use a unique temporary filename for concurrent safety
+	tmpFile := filePath + ".tmp." + strconv.FormatInt(time.Now().UnixNano(), 10)
+
+	f, err := os.Create(tmpFile)
+	if err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to create file: %s", tmpFile)
+		return
+	}
+
+	// Track if we've closed the file
+	fileClosed := false
+	defer func() {
+		// Only close if not already closed
+		if !fileClosed {
+			_ = f.Close()
+		}
+		// Clean up the temp file if it still exists and rename failed
+		_ = os.Remove(tmpFile)
+	}()
+
+	w := bufio.NewWriter(f)
+	if _, err := w.Write(data); err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to write data: %s", tmpFile)
+		return
+	}
+
+	if err := w.Flush(); err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to flush data: %s", tmpFile)
+		return
+	}
+
+	// Close the file before renaming
+	_ = f.Close()
+	fileClosed = true
+
+	if err := os.Rename(tmpFile, filePath); err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to rename file: %s", tmpFile)
+		return
+	}
+}
+
+func (c *Cache) ProcessTorrent(t *types.Torrent) error {
+
+	isComplete := func(files map[string]types.File) bool {
+		_complete := len(files) > 0
+		for _, file := range files {
+			if file.Link == "" {
+				_complete = false
+				break
+			}
+		}
+		return _complete
+	}
+
+	if !isComplete(t.Files) {
+		if err := c.client.UpdateTorrent(t); err != nil {
+			return fmt.Errorf("failed to update torrent: %w", err)
+		}
+	}
+
+	if !isComplete(t.Files) {
+		c.logger.Debug().Msgf("Torrent %s is still not complete. Triggering a reinsert(disabled)", t.Id)
+	} else {
+		addedOn, err := time.Parse(time.RFC3339, t.Added)
+		if err != nil {
+			addedOn = time.Now()
+		}
+		ct := CachedTorrent{
+			Torrent:    t,
+			IsComplete: len(t.Files) > 0,
+			AddedOn:    addedOn,
+		}
+		c.setTorrent(ct, func(tor CachedTorrent) {
+			c.listingDebouncer.Call(false)
+		})
+	}
+	return nil
+}
+
+func (c *Cache) Add(t *types.Torrent) error {
+	if len(t.Files) == 0 {
+		c.logger.Warn().Msgf("Torrent %s has no files to add. Refreshing", t.Id)
+		if err := c.client.UpdateTorrent(t); err != nil {
+			return fmt.Errorf("failed to update torrent: %w", err)
+		}
+	}
+	addedOn, err := time.Parse(time.RFC3339, t.Added)
+	if err != nil {
+		addedOn = time.Now()
+	}
+	ct := CachedTorrent{
+		Torrent:    t,
+		IsComplete: len(t.Files) > 0,
+		AddedOn:    addedOn,
+	}
+	c.setTorrent(ct, func(tor CachedTorrent) {
+		c.RefreshListings(true)
+	})
+	go c.GetFileDownloadLinks(ct)
+	return nil
+
+}
+
+func (c *Cache) Client() types.Client {
+	return c.client
+}
+
+func (c *Cache) DeleteTorrent(id string) error {
+	c.torrentsRefreshMu.Lock()
+	defer c.torrentsRefreshMu.Unlock()
+
+	if c.deleteTorrent(id, true) {
+		go c.RefreshListings(true)
+		return nil
+	}
+	return nil
+}
+
+func (c *Cache) validateAndDeleteTorrents(torrents []string) {
+	wg := sync.WaitGroup{}
+	for _, torrent := range torrents {
+		wg.Add(1)
+		go func(t string) {
+			defer wg.Done()
+			// Check if torrent is truly deleted
+			if _, err := c.client.GetTorrent(t); err != nil {
+				c.deleteTorrent(t, false) // Since it's removed from debrid already
+			}
+		}(torrent)
+	}
+	wg.Wait()
+	c.listingDebouncer.Call(true)
+}
+
+// deleteTorrent deletes the torrent from the cache and debrid service
+// It also handles torrents with the same name but different IDs
+func (c *Cache) deleteTorrent(id string, removeFromDebrid bool) bool {
+
+	if torrent, ok := c.torrents.getByID(id); ok {
+		c.torrents.removeId(id) // Delete id from cache
+		defer func() {
+			c.removeFile(id, false)
+			if removeFromDebrid {
+				_ = c.client.DeleteTorrent(id) // Skip error handling, we don't care if it fails
+			}
+		}() // defer delete from debrid
+
+		torrentName := c.GetTorrentFolder(torrent.Torrent)
+
+		if t, ok := c.torrents.getByName(torrentName); ok {
+
+			newFiles := map[string]types.File{}
+			newId := ""
+			for _, file := range t.GetFiles() {
+				if file.TorrentId != "" && file.TorrentId != id {
+					if newId == "" && file.TorrentId != "" {
+						newId = file.TorrentId
+					}
+					newFiles[file.Name] = file
+				}
+			}
+			if len(newFiles) == 0 {
+				// Delete the torrent since no files are left
+				c.torrents.remove(torrentName)
+			} else {
+				t.Files = newFiles
+				newId = cmp.Or(newId, t.Id)
+				t.Id = newId
+				c.setTorrent(t, nil) // This gets called after calling deleteTorrent
+			}
+		}
+		return true
+	}
+	return false
+}
+
+func (c *Cache) DeleteTorrents(ids []string) {
+	c.logger.Info().Msgf("Deleting %d torrents", len(ids))
+	for _, id := range ids {
+		_ = c.deleteTorrent(id, true)
+	}
+	c.listingDebouncer.Call(true)
+}
+
+func (c *Cache) removeFile(torrentId string, moveToTrash bool) {
+	// Moves the torrent file to the trash
+	filePath := filepath.Join(c.dir, torrentId+".json")
+
+	// Check if the file exists
+	if _, err := os.Stat(filePath); errors.Is(err, os.ErrNotExist) {
+		return
+	}
+
+	if !moveToTrash {
+		// If not moving to trash, delete the file directly
+		if err := os.Remove(filePath); err != nil {
+			c.logger.Error().Err(err).Msgf("Failed to remove file: %s", filePath)
+			return
+		}
+		return
+	}
+	// Move the file to the trash
+	trashPath := filepath.Join(c.dir, "trash", torrentId+".json")
+	if err := os.MkdirAll(filepath.Dir(trashPath), 0755); err != nil {
+		return
+	}
+	if err := os.Rename(filePath, trashPath); err != nil {
+		return
+	}
+}
+
+func (c *Cache) OnRemove(torrentId string) {
+	c.logger.Debug().Msgf("OnRemove triggered for %s", torrentId)
+	err := c.DeleteTorrent(torrentId)
+	if err != nil {
+		c.logger.Error().Err(err).Msgf("Failed to delete torrent: %s", torrentId)
+		return
+	}
+}
+
+// RemoveFile removes a file from the torrent cache
+// TODO sends a re-insert that removes the file from debrid
+func (c *Cache) RemoveFile(torrentId string, filename string) error {
+	c.logger.Debug().Str("torrent_id", torrentId).Msgf("Removing file %s", filename)
+	torrent, ok := c.torrents.getByID(torrentId)
+	if !ok {
+		return fmt.Errorf("torrent %s not found", torrentId)
+	}
+	file, ok := torrent.GetFile(filename)
+	if !ok {
+		return fmt.Errorf("file %s not found in torrent %s", filename, torrentId)
+	}
+	file.Deleted = true
+	torrent.Files[filename] = file
+
+	// If the torrent has no files left, delete it
+	if len(torrent.GetFiles()) == 0 {
+		c.logger.Debug().Msgf("Torrent %s has no files left, deleting it", torrentId)
+		if err := c.DeleteTorrent(torrentId); err != nil {
+			return fmt.Errorf("failed to delete torrent %s: %w", torrentId, err)
+		}
+		return nil
+	}
+
+	c.setTorrent(torrent, func(torrent CachedTorrent) {
+		c.listingDebouncer.Call(true)
+	}) // Update the torrent in the cache
+	return nil
+}
+
+func (c *Cache) Logger() zerolog.Logger {
+	return c.logger
+}

pkg/debrid/store/download_link.go

@@ -0,0 +1,193 @@
+package store
+
+import (
+	"errors"
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/utils"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+)
+
+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, err := c.checkDownloadLink(fileLink); dl != "" && err == nil {
+		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)
+
+	dl, err := c.fetchDownloadLink(torrentName, filename, fileLink)
+	if err != nil {
+		req.Complete("", err)
+		c.downloadLinkRequests.Delete(fileLink)
+		return "", err
+	}
+
+	if dl == nil || dl.DownloadLink == "" {
+		err = fmt.Errorf("download link is empty for %s in torrent %s", filename, torrentName)
+		req.Complete("", err)
+		c.downloadLinkRequests.Delete(fileLink)
+		return "", err
+	}
+	req.Complete(dl.DownloadLink, err)
+	c.downloadLinkRequests.Delete(fileLink)
+	return dl.DownloadLink, err
+}
+
+func (c *Cache) fetchDownloadLink(torrentName, filename, fileLink string) (*types.DownloadLink, error) {
+	ct := c.GetTorrentByName(torrentName)
+	if ct == nil {
+		return nil, fmt.Errorf("torrent not found")
+	}
+	file, ok := ct.GetFile(filename)
+	if !ok {
+		return nil, 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 nil, fmt.Errorf("failed to refresh torrent")
+		} else {
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return nil, 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 nil, fmt.Errorf("failed to reinsert torrent. %w", err)
+		}
+		ct = newCt
+		file, ok = ct.GetFile(filename)
+		if !ok {
+			return nil, 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, utils.HosterUnavailableError) {
+			newCt, err := c.reInsertTorrent(ct)
+			if err != nil {
+				return nil, fmt.Errorf("failed to reinsert torrent: %w", err)
+			}
+			ct = newCt
+			file, ok = ct.GetFile(filename)
+			if !ok {
+				return nil, 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 nil, err
+			}
+			if downloadLink == nil {
+				return nil, fmt.Errorf("download link is empty for")
+			}
+			return nil, nil
+		} else if errors.Is(err, utils.TrafficExceededError) {
+			// This is likely a fair usage limit error
+			return nil, err
+		} else {
+			return nil, fmt.Errorf("failed to get download link: %w", err)
+		}
+	}
+	if downloadLink == nil {
+		return nil, fmt.Errorf("download link is empty")
+	}
+
+	// Set link to cache
+	go c.client.Accounts().SetDownloadLink(fileLink, downloadLink)
+	return downloadLink, nil
+}
+
+func (c *Cache) GetFileDownloadLinks(t CachedTorrent) {
+	if err := c.client.GetFileDownloadLinks(t.Torrent); err != nil {
+		c.logger.Error().Err(err).Str("torrent", t.Name).Msg("Failed to generate download links")
+		return
+	}
+}
+
+func (c *Cache) checkDownloadLink(link string) (string, error) {
+
+	dl, err := c.client.Accounts().GetDownloadLink(link)
+	if err != nil {
+		return "", err
+	}
+	if !c.downloadLinkIsInvalid(dl.DownloadLink) {
+		return dl.DownloadLink, nil
+	}
+	return "", fmt.Errorf("download link not found for %s", link)
+}
+
+func (c *Cache) MarkDownloadLinkAsInvalid(link, downloadLink, reason string) {
+	c.invalidDownloadLinks.Store(downloadLink, reason)
+	// Remove the download api key from active
+	if reason == "bandwidth_exceeded" {
+		// Disable the account
+		_, account, err := c.client.Accounts().GetDownloadLinkWithAccount(link)
+		if err != nil {
+			return
+		}
+		c.client.Accounts().Disable(account)
+	}
+}
+
+func (c *Cache) downloadLinkIsInvalid(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
+}
+
+func (c *Cache) GetDownloadByteRange(torrentName, filename string) (*[2]int64, error) {
+	ct := c.GetTorrentByName(torrentName)
+	if ct == nil {
+		return nil, fmt.Errorf("torrent not found")
+	}
+	file := ct.Files[filename]
+	return file.ByteRange, nil
+}
+
+func (c *Cache) GetTotalActiveDownloadLinks() int {
+	return c.client.Accounts().GetLinksCount()
+}

pkg/debrid/store/misc.go

@@ -0,0 +1,42 @@
+package store
+
+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
+}
+
+func (c *Cache) GetIngests() ([]types.IngestData, error) {
+	torrents := c.GetTorrents()
+	debridName := c.client.Name()
+	var ingests []types.IngestData
+	for _, torrent := range torrents {
+		ingests = append(ingests, types.IngestData{
+			Debrid: debridName,
+			Name:   torrent.Filename,
+			Hash:   torrent.InfoHash,
+			Size:   torrent.Bytes,
+		})
+	}
+	return ingests, nil
+}

pkg/debrid/store/refresh.go

@@ -0,0 +1,262 @@
+package store
+
+import (
+	"context"
+	"fmt"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"io"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"time"
+)
+
+type fileInfo struct {
+	id      string
+	name    string
+	size    int64
+	mode    os.FileMode
+	modTime time.Time
+	isDir   bool
+}
+
+func (fi *fileInfo) Name() string       { return fi.name }
+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(refreshRclone bool) {
+	// Copy the torrents to a string|time map
+	c.torrents.refreshListing() // refresh torrent listings
+
+	if refreshRclone {
+		if err := c.refreshRclone(); err != nil {
+			c.logger.Error().Err(err).Msg("Failed to refresh rclone") // silent error
+		}
+	}
+}
+
+func (c *Cache) refreshTorrents(ctx context.Context) {
+	select {
+	case <-ctx.Done():
+		return
+	default:
+	}
+
+	if !c.torrentsRefreshMu.TryLock() {
+		return
+	}
+	defer c.torrentsRefreshMu.Unlock()
+
+	// Get all torrents from the debrid service
+	debTorrents, err := c.client.GetTorrents()
+	if err != nil {
+		c.logger.Error().Err(err).Msg("Failed to get torrents")
+		return
+	}
+
+	if len(debTorrents) == 0 {
+		// Maybe an error occurred
+		return
+	}
+
+	currentTorrentIds := make(map[string]struct{}, len(debTorrents))
+	for _, t := range debTorrents {
+		currentTorrentIds[t.Id] = struct{}{}
+	}
+
+	// Let's implement deleting torrents removed from debrid
+	deletedTorrents := make([]string, 0)
+	cachedTorrents := c.torrents.getIdMaps()
+	for id := range cachedTorrents {
+		if _, exists := currentTorrentIds[id]; !exists {
+			deletedTorrents = append(deletedTorrents, id)
+		}
+	}
+
+	if len(deletedTorrents) > 0 {
+		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.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 {
+				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 {
+		workChan <- t
+	}
+	close(workChan)
+	wg.Wait()
+
+	c.listingDebouncer.Call(false)
+
+	c.logger.Debug().Msgf("Processed %d new torrents", counter)
+}
+
+func (c *Cache) refreshRclone() error {
+	cfg := c.config
+
+	if cfg.RcUrl == "" {
+		return nil
+	}
+
+	if cfg.RcUrl == "" {
+		return nil
+	}
+
+	client := &http.Client{
+		Timeout: 60 * time.Second,
+		Transport: &http.Transport{
+			MaxIdleConns:        10,
+			IdleConnTimeout:     60 * time.Second,
+			DisableCompression:  false,
+			MaxIdleConnsPerHost: 5,
+		},
+	}
+	// Create form data
+	data := c.buildRcloneRequestData()
+
+	if err := c.sendRcloneRequest(client, "vfs/forget", data); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to send rclone vfs/forget request")
+	}
+
+	if err := c.sendRcloneRequest(client, "vfs/refresh", data); err != nil {
+		c.logger.Error().Err(err).Msg("Failed to send rclone vfs/refresh request")
+	}
+
+	return nil
+}
+
+func (c *Cache) buildRcloneRequestData() string {
+	cfg := c.config
+	dirs := strings.FieldsFunc(cfg.RcRefreshDirs, func(r rune) bool {
+		return r == ',' || r == '&'
+	})
+
+	if len(dirs) == 0 {
+		return "dir=__all__"
+	}
+
+	var data strings.Builder
+	for index, dir := range dirs {
+		if dir != "" {
+			if index == 0 {
+				data.WriteString("dir=" + dir)
+			} else {
+				data.WriteString("&dir" + fmt.Sprint(index+1) + "=" + dir)
+			}
+		}
+	}
+	return data.String()
+}
+
+func (c *Cache) sendRcloneRequest(client *http.Client, endpoint, data string) error {
+	req, err := http.NewRequest("POST", fmt.Sprintf("%s/%s", c.config.RcUrl, endpoint), strings.NewReader(data))
+	if err != nil {
+		return err
+	}
+
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	if c.config.RcUser != "" && c.config.RcPass != "" {
+		req.SetBasicAuth(c.config.RcUser, c.config.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
+}
+
+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.Error().Err(err).Msgf("Failed to get torrent %s", torrentId)
+		return nil
+	}
+	addedOn, err := time.Parse(time.RFC3339, torrent.Added)
+	if err != nil {
+		addedOn = time.Now()
+	}
+	ct := CachedTorrent{
+		Torrent:    torrent,
+		AddedOn:    addedOn,
+		IsComplete: len(torrent.Files) > 0,
+	}
+	c.setTorrent(ct, func(torrent CachedTorrent) {
+		go c.listingDebouncer.Call(true)
+	})
+
+	return &ct
+}
+
+func (c *Cache) refreshDownloadLinks(ctx context.Context) {
+
+	select {
+	case <-ctx.Done():
+		return
+	default:
+	}
+
+	if !c.downloadLinksRefreshMu.TryLock() {
+		return
+	}
+	defer c.downloadLinksRefreshMu.Unlock()
+
+	links, err := c.client.GetDownloadLinks()
+
+	if err != nil {
+		c.logger.Error().Err(err).Msg("Failed to get download links")
+		return
+	}
+
+	c.client.Accounts().SetDownloadLinks(links)
+
+	c.logger.Debug().Msgf("Refreshed download %d links", c.client.Accounts().GetLinksCount())
+}

pkg/debrid/store/repair.go

@@ -0,0 +1,284 @@
+package store
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/sirrobot01/decypharr/internal/utils"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"sync"
+	"time"
+)
+
+type reInsertRequest struct {
+	result *CachedTorrent
+	err    error
+	done   chan struct{}
+}
+
+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 utils.Contains(filenames, name) {
+				files[name] = f
+			}
+		}
+	} else {
+		files = t.Files
+	}
+	for _, f := range files {
+		// Check if file is missing
+		if f.Link == "" {
+			// refresh torrent and then 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
+	var wg sync.WaitGroup
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	wg.Add(len(files))
+
+	for _, f := range files {
+		go func(f types.File) {
+			defer wg.Done()
+
+			select {
+			case <-ctx.Done():
+				return
+			default:
+			}
+
+			if f.Link == "" {
+				cancel()
+				return
+			}
+
+			if err := c.client.CheckLink(f.Link); err != nil {
+				if errors.Is(err, utils.HosterUnavailableError) {
+					cancel() // Signal all other goroutines to stop
+					return
+				}
+			}
+		}(f)
+	}
+
+	wg.Wait()
+
+	// If context was cancelled, mark all files as broken
+	if ctx.Err() != nil {
+		for _, f := range files {
+			brokenFiles = append(brokenFiles, f.Name)
+		}
+	}
+
+	// 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(ctx context.Context) {
+	// This watches a channel for torrents to repair and can be cancelled via context
+	for {
+		select {
+		case <-ctx.Done():
+			return
+
+		case req, ok := <-c.repairChan:
+			// Channel was closed
+			if !ok {
+				c.logger.Debug().Msg("Repair channel closed, shutting down worker")
+				return
+			}
+
+			torrentId := req.TorrentID
+			c.logger.Debug().Str("torrentId", req.TorrentID).Msg("Received repair request")
+
+			// 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
+			}
+
+			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
+				}
+			}
+		}
+	}
+}
+
+func (c *Cache) reInsertTorrent(ct *CachedTorrent) (*CachedTorrent, error) {
+	// Check if Magnet is not empty, if empty, reconstruct the magnet
+	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 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)
+
+	// Make sure we clean up even if there's a panic
+	defer func() {
+		c.repairRequest.Delete(oldID)
+	}()
+
+	// Submit the magnet to the debrid service
+	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
+	newTorrent, err = c.client.SubmitMagnet(newTorrent)
+	if err != nil {
+		c.markAsFailedToReinsert(oldID)
+		// Remove the old torrent from the cache and debrid service
+		return ct, fmt.Errorf("failed to submit magnet: %w", err)
+	}
+
+	// Check if the torrent was submitted
+	if newTorrent == nil || newTorrent.Id == "" {
+		c.markAsFailedToReinsert(oldID)
+		return ct, fmt.Errorf("failed to submit magnet: empty torrent")
+	}
+	newTorrent.DownloadUncached = false // Set to false, avoid re-downloading
+	newTorrent, err = c.client.CheckStatus(newTorrent)
+	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, newTorrent.Added)
+	if err != nil {
+		addedOn = time.Now()
+	}
+	for _, f := range newTorrent.GetFiles() {
+		if f.Link == "" {
+			c.markAsFailedToReinsert(oldID)
+			return ct, fmt.Errorf("failed to reinsert torrent: empty link")
+		}
+	}
+	// 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(ctx context.Context) {
+	c.logger.Debug().Msgf("Resetting accounts")
+	c.invalidDownloadLinks = sync.Map{}
+	c.client.Accounts().Reset() // Reset the active download keys
+
+	// Refresh the download links
+	c.refreshDownloadLinks(ctx)
+}

pkg/debrid/store/torrent.go

@@ -0,0 +1,328 @@
+package store
+
+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 torrents struct {
+	sync.RWMutex
+	byID   map[string]CachedTorrent
+	byName map[string]CachedTorrent
+}
+
+type folders struct {
+	sync.RWMutex
+	listing map[string][]os.FileInfo // folder name to file listing
+}
+
+type torrentCache struct {
+	torrents torrents
+
+	listing            atomic.Value
+	folders            folders
+	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{
+		torrents: torrents{
+			byID:   make(map[string]CachedTorrent),
+			byName: make(map[string]CachedTorrent),
+		},
+		folders: folders{
+			listing: 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.torrents.Lock()
+	tc.torrents.byID = make(map[string]CachedTorrent)
+	tc.torrents.byName = make(map[string]CachedTorrent)
+	tc.torrents.Unlock()
+
+	// reset the sorted listing
+	tc.sortNeeded.Store(false)
+	tc.listing.Store(make([]os.FileInfo, 0))
+
+	// reset any per-folder views
+	tc.folders.Lock()
+	tc.folders.listing = make(map[string][]os.FileInfo)
+	tc.folders.Unlock()
+}
+
+func (tc *torrentCache) getByID(id string) (CachedTorrent, bool) {
+	tc.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	torrent, exists := tc.torrents.byID[id]
+	return torrent, exists
+}
+
+func (tc *torrentCache) getByName(name string) (CachedTorrent, bool) {
+	tc.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	torrent, exists := tc.torrents.byName[name]
+	return torrent, exists
+}
+
+func (tc *torrentCache) set(name string, torrent, newTorrent CachedTorrent) {
+	tc.torrents.Lock()
+	// Set the id first
+
+	tc.torrents.byName[name] = torrent
+	tc.torrents.byID[torrent.Id] = torrent // This is the unadulterated torrent
+	tc.torrents.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.folders.RLock()
+	defer tc.folders.RUnlock()
+	if folderName == "" {
+		return tc.getListing()
+	}
+	if folder, ok := tc.folders.listing[folderName]; ok {
+		return folder
+	}
+	// If folder not found, return empty slice
+	return []os.FileInfo{}
+}
+
+func (tc *torrentCache) refreshListing() {
+
+	tc.torrents.RLock()
+	all := make([]sortableFile, 0, len(tc.torrents.byName))
+	for name, t := range tc.torrents.byName {
+		all = append(all, sortableFile{t.Id, name, t.AddedOn, t.Bytes, t.Bad})
+	}
+	tc.sortNeeded.Store(false)
+	tc.torrents.RUnlock()
+
+	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() {
+		defer wg.Done()
+		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.Add(1)
+	// For __bad__
+	go func() {
+		defer wg.Done()
+		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.folders.Lock()
+		if len(listing) > 0 {
+			tc.folders.listing["__bad__"] = listing
+		} else {
+			delete(tc.folders.listing, "__bad__")
+		}
+		tc.folders.Unlock()
+	}()
+
+	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.folders.Lock()
+			if len(matched) > 0 {
+				tc.folders.listing[dir] = matched
+			} else {
+				delete(tc.folders.listing, dir)
+			}
+			tc.folders.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.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	result := make(map[string]CachedTorrent, len(tc.torrents.byID))
+	for name, torrent := range tc.torrents.byID {
+		result[name] = torrent
+	}
+	return result
+}
+
+func (tc *torrentCache) getAllCount() int {
+	tc.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	return len(tc.torrents.byID)
+}
+
+func (tc *torrentCache) getAllByName() map[string]CachedTorrent {
+	tc.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	results := make(map[string]CachedTorrent, len(tc.torrents.byName))
+	for name, torrent := range tc.torrents.byName {
+		results[name] = torrent
+	}
+	return results
+}
+
+func (tc *torrentCache) getIdMaps() map[string]struct{} {
+	tc.torrents.RLock()
+	defer tc.torrents.RUnlock()
+	res := make(map[string]struct{}, len(tc.torrents.byID))
+	for id := range tc.torrents.byID {
+		res[id] = struct{}{}
+	}
+	return res
+}
+
+func (tc *torrentCache) removeId(id string) {
+	tc.torrents.Lock()
+	defer tc.torrents.Unlock()
+	delete(tc.torrents.byID, id)
+	tc.sortNeeded.Store(true)
+}
+
+func (tc *torrentCache) remove(name string) {
+	tc.torrents.Lock()
+	defer tc.torrents.Unlock()
+	delete(tc.torrents.byName, name)
+	tc.sortNeeded.Store(true)
+}

pkg/debrid/store/worker.go

@@ -0,0 +1,60 @@
+package store
+
+import (
+	"context"
+	"github.com/go-co-op/gocron/v2"
+	"github.com/sirrobot01/decypharr/internal/utils"
+)
+
+func (c *Cache) StartSchedule(ctx context.Context) error {
+	// For now, we just want to refresh the listing and download links
+
+	// 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(ctx)
+		}), 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
+}

pkg/debrid/store/xml.go

@@ -0,0 +1 @@
+package store

pkg/debrid/types/account.go

@@ -0,0 +1,243 @@
+package types
+
+import (
+	"github.com/sirrobot01/decypharr/internal/config"
+	"sync"
+	"time"
+)
+
+type Accounts struct {
+	current  *Account
+	accounts []*Account
+	mu       sync.RWMutex
+}
+
+func NewAccounts(debridConf config.Debrid) *Accounts {
+	accounts := make([]*Account, 0)
+	for idx, token := range debridConf.DownloadAPIKeys {
+		if token == "" {
+			continue
+		}
+		account := newAccount(debridConf.Name, token, idx)
+		accounts = append(accounts, account)
+	}
+
+	var current *Account
+	if len(accounts) > 0 {
+		current = accounts[0]
+	}
+	return &Accounts{
+		accounts: accounts,
+		current:  current,
+	}
+}
+
+type Account struct {
+	Debrid   string // e.g., "realdebrid", "torbox", etc.
+	Order    int
+	Disabled bool
+	Token    string
+	links    map[string]*DownloadLink
+	mu       sync.RWMutex
+}
+
+func (a *Accounts) All() []*Account {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	activeAccounts := make([]*Account, 0)
+	for _, acc := range a.accounts {
+		if !acc.Disabled {
+			activeAccounts = append(activeAccounts, acc)
+		}
+	}
+	return activeAccounts
+}
+
+func (a *Accounts) Current() *Account {
+	a.mu.RLock()
+	if a.current != nil {
+		current := a.current
+		a.mu.RUnlock()
+		return current
+	}
+	a.mu.RUnlock()
+
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	// Double-check after acquiring write lock
+	if a.current != nil {
+		return a.current
+	}
+
+	activeAccounts := make([]*Account, 0)
+	for _, acc := range a.accounts {
+		if !acc.Disabled {
+			activeAccounts = append(activeAccounts, acc)
+		}
+	}
+
+	if len(activeAccounts) > 0 {
+		a.current = activeAccounts[0]
+	}
+	return a.current
+}
+
+func (a *Accounts) Disable(account *Account) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	account.disable()
+
+	if a.current == account {
+		var newCurrent *Account
+		for _, acc := range a.accounts {
+			if !acc.Disabled {
+				newCurrent = acc
+				break
+			}
+		}
+		a.current = newCurrent
+	}
+}
+
+func (a *Accounts) Reset() {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, acc := range a.accounts {
+		acc.resetDownloadLinks()
+		acc.Disabled = false
+	}
+	if len(a.accounts) > 0 {
+		a.current = a.accounts[0]
+	} else {
+		a.current = nil
+	}
+}
+
+func (a *Accounts) GetDownloadLink(fileLink string) (*DownloadLink, error) {
+	if a.Current() == nil {
+		return nil, NoActiveAccountsError
+	}
+	dl, ok := a.Current().getLink(fileLink)
+	if !ok {
+		return nil, NoDownloadLinkError
+	}
+	if dl.ExpiresAt.IsZero() || dl.ExpiresAt.Before(time.Now()) {
+		return nil, DownloadLinkExpiredError
+	}
+	if dl.DownloadLink == "" {
+		return nil, EmptyDownloadLinkError
+	}
+	return dl, nil
+}
+
+func (a *Accounts) GetDownloadLinkWithAccount(fileLink string) (*DownloadLink, *Account, error) {
+	currentAccount := a.Current()
+	if currentAccount == nil {
+		return nil, nil, NoActiveAccountsError
+	}
+	dl, ok := currentAccount.getLink(fileLink)
+	if !ok {
+		return nil, nil, NoDownloadLinkError
+	}
+	if dl.ExpiresAt.IsZero() || dl.ExpiresAt.Before(time.Now()) {
+		return nil, currentAccount, DownloadLinkExpiredError
+	}
+	if dl.DownloadLink == "" {
+		return nil, currentAccount, EmptyDownloadLinkError
+	}
+	return dl, currentAccount, nil
+}
+
+func (a *Accounts) SetDownloadLink(fileLink string, dl *DownloadLink) {
+	if a.Current() == nil {
+		return
+	}
+	a.Current().setLink(fileLink, dl)
+}
+
+func (a *Accounts) DeleteDownloadLink(fileLink string) {
+	if a.Current() == nil {
+		return
+	}
+	a.Current().deleteLink(fileLink)
+}
+
+func (a *Accounts) GetLinksCount() int {
+	if a.Current() == nil {
+		return 0
+	}
+	return a.Current().LinksCount()
+}
+
+func (a *Accounts) SetDownloadLinks(links map[string]*DownloadLink) {
+	if a.Current() == nil {
+		return
+	}
+	a.Current().setLinks(links)
+}
+
+func newAccount(debridName, token string, index int) *Account {
+	return &Account{
+		Debrid: debridName,
+		Token:  token,
+		Order:  index,
+		links:  make(map[string]*DownloadLink),
+	}
+}
+
+func (a *Account) getLink(fileLink string) (*DownloadLink, bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	dl, ok := a.links[a.sliceFileLink(fileLink)]
+	return dl, ok
+}
+func (a *Account) setLink(fileLink string, dl *DownloadLink) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.links[a.sliceFileLink(fileLink)] = dl
+}
+func (a *Account) deleteLink(fileLink string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	delete(a.links, a.sliceFileLink(fileLink))
+}
+func (a *Account) resetDownloadLinks() {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.links = make(map[string]*DownloadLink)
+}
+func (a *Account) LinksCount() int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return len(a.links)
+}
+
+func (a *Account) disable() {
+	a.Disabled = true
+}
+
+func (a *Account) setLinks(links map[string]*DownloadLink) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	now := time.Now()
+	for _, dl := range links {
+		if !dl.ExpiresAt.IsZero() && dl.ExpiresAt.Before(now) {
+			// Expired, continue
+			continue
+		}
+		a.links[a.sliceFileLink(dl.Link)] = dl
+	}
+}
+
+// slice download link
+func (a *Account) sliceFileLink(fileLink string) string {
+	if a.Debrid != "realdebrid" {
+		return fileLink
+	}
+	if len(fileLink) < 39 {
+		return fileLink
+	}
+	return fileLink[0:39]
+}

pkg/debrid/types/client.go

@@ -6,21 +6,23 @@ import (
 
 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)
+	CheckStatus(tr *Torrent) (*Torrent, error)
+	GetFileDownloadLinks(tr *Torrent) 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
+	Name() string
+	Logger() zerolog.Logger
 	GetDownloadingStatus() []string
-	GetDownloads() (map[string]DownloadLinks, error)
+	GetDownloadLinks() (map[string]*DownloadLink, error)
 	CheckLink(link string) error
 	GetMountPath() string
-	DisableAccount(string)
-	ResetActiveDownloadKeys()
+	Accounts() *Accounts // Returns the active download account/token
+	DeleteDownloadLink(linkId string) error
+	GetProfile() (*Profile, error)
+	GetAvailableSlots() (int, error)
 }

pkg/debrid/types/error.go

@@ -0,0 +1,30 @@
+package types
+
+type Error struct {
+	Message string `json:"message"`
+	Code    string `json:"code"`
+}
+
+func (e *Error) Error() string {
+	return e.Message
+}
+
+var NoActiveAccountsError = &Error{
+	Message: "No active accounts",
+	Code:    "no_active_accounts",
+}
+
+var NoDownloadLinkError = &Error{
+	Message: "No download link found",
+	Code:    "no_download_link",
+}
+
+var DownloadLinkExpiredError = &Error{
+	Message: "Download link expired",
+	Code:    "download_link_expired",
+}
+
+var EmptyDownloadLinkError = &Error{
+	Message: "Download link is empty",
+	Code:    "empty_download_link",
+}

pkg/debrid/types/torrent.go

@@ -2,14 +2,14 @@ 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"
 	"os"
 	"path/filepath"
 	"sync"
 	"time"
+
+	"github.com/sirrobot01/decypharr/internal/logger"
+	"github.com/sirrobot01/decypharr/internal/utils"
+	"github.com/sirrobot01/decypharr/pkg/arr"
 )
 
 type Torrent struct {
@@ -30,22 +30,16 @@ 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"`
 
-	Arr              *arr.Arr   `json:"arr"`
-	Mu               sync.Mutex `json:"-"`
-	SizeDownloaded   int64      `json:"-"` // This is used for local download
-	DownloadUncached bool       `json:"-"`
-}
+	Arr *arr.Arr `json:"arr"`
 
-type DownloadLinks 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"`
+	SizeDownloaded   int64 `json:"-"` // This is used for local download
+	DownloadUncached bool  `json:"-"`
+
+	sync.Mutex
 }
 
 func (t *Torrent) GetSymlinkFolder(parent string) string {
@@ -53,7 +47,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 +65,37 @@ 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"`
+	IsRar        bool          `json:"is_rar"`
+	ByteRange    *[2]int64     `json:"byte_range,omitempty"`
+	Path         string        `json:"path"`
+	Link         string        `json:"link"`
+	AccountId    string        `json:"account_id"`
+	Generated    time.Time     `json:"generated"`
+	Deleted      bool          `json:"deleted"`
+	DownloadLink *DownloadLink `json:"-"`
 }
 
 func (t *Torrent) Cleanup(remove bool) {
@@ -111,18 +107,38 @@ 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 IngestData struct {
+	Debrid string `json:"debrid"`
+	Name   string `json:"name"`
+	Hash   string `json:"hash"`
+	Size   int64  `json:"size"`
 }
 
-type Account struct {
-	ID       string `json:"id"`
-	Disabled bool   `json:"disabled"`
-	Name     string `json:"name"`
-	Token    string `json:"token"`
+type Profile struct {
+	Name       string    `json:"name"`
+	Id         int64     `json:"id"`
+	Username   string    `json:"username"`
+	Email      string    `json:"email"`
+	Points     int64     `json:"points"`
+	Type       string    `json:"type"`
+	Premium    int       `json:"premium"`
+	Expiration time.Time `json:"expiration"`
+
+	LibrarySize int `json:"library_size"`
+	BadTorrents int `json:"bad_torrents"`
+	ActiveLinks int `json:"active_links"`
+}
+
+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"`
+	ExpiresAt    time.Time
+}
+
+func (d *DownloadLink) String() string {
+	return d.DownloadLink
 }

pkg/qbit/context.go

@@ -0,0 +1,178 @@
+package qbit
+
+import (
+	"context"
+	"encoding/base64"
+	"fmt"
+	"github.com/go-chi/chi/v5"
+	"github.com/sirrobot01/decypharr/pkg/arr"
+	"github.com/sirrobot01/decypharr/pkg/store"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+type contextKey string
+
+const (
+	categoryKey contextKey = "category"
+	hashesKey   contextKey = "hashes"
+	arrKey      contextKey = "arr"
+)
+
+func validateServiceURL(urlStr string) error {
+	if urlStr == "" {
+		return fmt.Errorf("URL cannot be empty")
+	}
+
+	// Try parsing as full URL first
+	u, err := url.Parse(urlStr)
+	if err == nil && u.Scheme != "" && u.Host != "" {
+		// It's a full URL, validate scheme
+		if u.Scheme != "http" && u.Scheme != "https" {
+			return fmt.Errorf("URL scheme must be http or https")
+		}
+		return nil
+	}
+
+	// Check if it's a host:port format (no scheme)
+	if strings.Contains(urlStr, ":") && !strings.Contains(urlStr, "://") {
+		// Try parsing with http:// prefix
+		testURL := "http://" + urlStr
+		u, err := url.Parse(testURL)
+		if err != nil {
+			return fmt.Errorf("invalid host:port format: %w", err)
+		}
+
+		if u.Host == "" {
+			return fmt.Errorf("host is required in host:port format")
+		}
+
+		// Validate port number
+		if u.Port() == "" {
+			return fmt.Errorf("port is required in host:port format")
+		}
+
+		return nil
+	}
+
+	return fmt.Errorf("invalid URL format: %s", urlStr)
+}
+
+func getCategory(ctx context.Context) string {
+	if category, ok := ctx.Value(categoryKey).(string); ok {
+		return category
+	}
+	return ""
+}
+
+func getHashes(ctx context.Context) []string {
+	if hashes, ok := ctx.Value(hashesKey).([]string); ok {
+		return hashes
+	}
+	return nil
+}
+
+func getArrFromContext(ctx context.Context) *arr.Arr {
+	if a, ok := ctx.Value(arrKey).(*arr.Arr); ok {
+		return a
+	}
+	return nil
+}
+
+func decodeAuthHeader(header string) (string, string, error) {
+	encodedTokens := strings.Split(header, " ")
+	if len(encodedTokens) != 2 {
+		return "", "", nil
+	}
+	encodedToken := encodedTokens[1]
+
+	bytes, err := base64.StdEncoding.DecodeString(encodedToken)
+	if err != nil {
+		return "", "", err
+	}
+
+	bearer := string(bytes)
+
+	colonIndex := strings.LastIndex(bearer, ":")
+	host := bearer[:colonIndex]
+	token := bearer[colonIndex+1:]
+
+	return host, token, nil
+}
+
+func (q *QBit) categoryContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		category := strings.Trim(r.URL.Query().Get("category"), "")
+		if category == "" {
+			// Get from form
+			_ = r.ParseForm()
+			category = r.Form.Get("category")
+			if category == "" {
+				// Get from multipart form
+				_ = r.ParseMultipartForm(32 << 20)
+				category = r.FormValue("category")
+			}
+		}
+		ctx := context.WithValue(r.Context(), categoryKey, strings.TrimSpace(category))
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+// authContext creates a middleware that extracts the Arr host and token from the Authorization header
+// and adds it to the request context.
+// This is used to identify the Arr instance for the request.
+// Only a valid host and token will be added to the context/config. The rest are manual
+func (q *QBit) authContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		host, token, err := decodeAuthHeader(r.Header.Get("Authorization"))
+		category := getCategory(r.Context())
+		arrs := store.Get().Arr()
+		// Check if arr exists
+		a := arrs.Get(category)
+		if a == nil {
+			// Arr is not configured, create a new one
+			downloadUncached := false
+			a = arr.New(category, "", "", false, false, &downloadUncached, "", "auto")
+		}
+		if err == nil {
+			host = strings.TrimSpace(host)
+			if host != "" {
+				a.Host = host
+			}
+			token = strings.TrimSpace(token)
+			if token != "" {
+				a.Token = token
+			}
+		}
+		a.Source = "auto"
+		if err := validateServiceURL(a.Host); err != nil {
+			// Return silently, no need to raise a problem. Just do not add the Arr to the context/config.json
+			next.ServeHTTP(w, r)
+			return
+		}
+		arrs.AddOrUpdate(a)
+		ctx := context.WithValue(r.Context(), arrKey, a)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func hashesContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_hashes := chi.URLParam(r, "hashes")
+		var hashes []string
+		if _hashes != "" {
+			hashes = strings.Split(_hashes, "|")
+		}
+		if hashes == nil {
+			// Get hashes from form
+			_ = r.ParseForm()
+			hashes = r.Form["hashes"]
+		}
+		for i, hash := range hashes {
+			hashes[i] = strings.TrimSpace(hash)
+		}
+		ctx := context.WithValue(r.Context(), hashesKey, hashes)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

pkg/qbit/downloader.go

@@ -1,268 +0,0 @@
-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"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-func Download(client *grab.Client, url, filename string, progressCallback func(int64, int64)) error {
-	req, err := grab.NewRequest(filename, url)
-	if err != nil {
-		return err
-	}
-	resp := client.Do(req)
-
-	t := time.NewTicker(time.Second)
-	defer t.Stop()
-
-	var lastReported int64
-Loop:
-	for {
-		select {
-		case <-t.C:
-			current := resp.BytesComplete()
-			speed := int64(resp.BytesPerSecond())
-			if current != lastReported {
-				if progressCallback != nil {
-					progressCallback(current-lastReported, speed)
-				}
-				lastReported = current
-			}
-		case <-resp.Done:
-			break Loop
-		}
-	}
-
-	// Report final bytes
-	if progressCallback != nil {
-		progressCallback(resp.BytesComplete()-lastReported, 0)
-	}
-
-	return resp.Err()
-}
-
-func (q *QBit) ProcessManualFile(torrent *Torrent) (string, error) {
-	debridTorrent := torrent.DebridTorrent
-	q.logger.Info().Msgf("Downloading %d files...", len(debridTorrent.Files))
-	torrentPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, utils.RemoveExtension(debridTorrent.OriginalFilename))
-	torrentPath = utils.RemoveInvalidChars(torrentPath)
-	err := os.MkdirAll(torrentPath, os.ModePerm)
-	if err != nil {
-		// add previous error to the error and return
-		return "", fmt.Errorf("failed to create directory: %s: %v", torrentPath, err)
-	}
-	q.downloadFiles(torrent, torrentPath)
-	return torrentPath, nil
-}
-
-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 {
-		totalSize += file.Size
-	}
-	debridTorrent.Mu.Lock()
-	debridTorrent.SizeDownloaded = 0 // Reset downloaded bytes
-	debridTorrent.Progress = 0       // Reset progress
-	debridTorrent.Mu.Unlock()
-	progressCallback := func(downloaded int64, speed int64) {
-		debridTorrent.Mu.Lock()
-		defer debridTorrent.Mu.Unlock()
-		torrent.Mu.Lock()
-		defer torrent.Mu.Unlock()
-
-		// Update total downloaded bytes
-		debridTorrent.SizeDownloaded += downloaded
-		debridTorrent.Speed = speed
-
-		// Calculate overall progress
-		if totalSize > 0 {
-			debridTorrent.Progress = float64(debridTorrent.SizeDownloaded) / float64(totalSize) * 100
-		}
-		q.UpdateTorrentMin(torrent, debridTorrent)
-	}
-	client := &grab.Client{
-		UserAgent:  "qBitTorrent",
-		HTTPClient: request.New(request.WithTimeout(0)),
-	}
-	for _, file := range debridTorrent.Files {
-		if file.DownloadLink == "" {
-			q.logger.Info().Msgf("No download link found for %s", file.Name)
-			continue
-		}
-		wg.Add(1)
-		semaphore <- struct{}{}
-		go func(file debrid.File) {
-			defer wg.Done()
-			defer func() { <-semaphore }()
-			filename := file.Link
-
-			err := Download(
-				client,
-				file.DownloadLink,
-				filepath.Join(parent, filename),
-				progressCallback,
-			)
-
-			if err != nil {
-				q.logger.Error().Msgf("Failed to download %s: %v", filename, err)
-			} else {
-				q.logger.Info().Msgf("Downloaded %s", filename)
-			}
-		}(file)
-	}
-	wg.Wait()
-	q.logger.Info().Msgf("Downloaded all files for %s", debridTorrent.Name)
-}
-
-func (q *QBit) ProcessSymlink(torrent *Torrent) (string, error) {
-	debridTorrent := torrent.DebridTorrent
-	files := debridTorrent.Files
-	if len(files) == 0 {
-		return "", fmt.Errorf("no video files found")
-	}
-	q.logger.Info().Msgf("Checking symlinks for %d files...", len(files))
-	rCloneBase := debridTorrent.MountPath
-	torrentPath, err := q.getTorrentPath(rCloneBase, debridTorrent) // /MyTVShow/
-	// This returns filename.ext for alldebrid instead of the parent folder filename/
-	torrentFolder := torrentPath
-	if err != nil {
-		return "", fmt.Errorf("failed to get torrent path: %v", err)
-	}
-	// Check if the torrent path is a file
-	torrentRclonePath := filepath.Join(rCloneBase, torrentPath) // leave it as is
-	if debridTorrent.Debrid == "alldebrid" && utils.IsMediaFile(torrentPath) {
-		// Alldebrid hotfix for single file torrents
-		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)
-	if err != nil {
-		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
-	}
-
-	pending := make(map[string]debrid.File)
-	for _, file := range files {
-		pending[file.Path] = file
-	}
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-	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)
-			}
-		}
-	}
-
-	if q.SkipPreCache {
-		return torrentSymlinkPath, nil
-	}
-
-	go func() {
-
-		if err := q.preCacheFile(debridTorrent.Name, filePaths); err != nil {
-			q.logger.Error().Msgf("Failed to pre-cache file: %s", err)
-		}
-	}() // 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) {
-	for {
-		torrentPath, err := debridTorrent.GetMountFolder(rclonePath)
-		if err == nil {
-			q.logger.Debug().Msgf("Found torrent path: %s", torrentPath)
-			return torrentPath, err
-		}
-		time.Sleep(100 * time.Millisecond)
-	}
-}
-
-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)
-	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)
-		}()
-	}
-
-	return nil
-}
-
-func (q *QBit) readSmallChunks(file *os.File, startPos int64, totalToRead int, chunkSize int) {
-	_, err := file.Seek(startPos, 0)
-	if err != nil {
-		return
-	}
-
-	buf := make([]byte, chunkSize)
-	bytesRemaining := totalToRead
-
-	for bytesRemaining > 0 {
-		toRead := chunkSize
-		if bytesRemaining < chunkSize {
-			toRead = bytesRemaining
-		}
-
-		n, err := file.Read(buf[:toRead])
-		if err != nil {
-			if err == io.EOF {
-				break
-			}
-			return
-		}
-
-		bytesRemaining -= n
-	}
-}

pkg/qbit/http.go

@@ -1,114 +1,24 @@
 package qbit
 
 import (
-	"context"
-	"encoding/base64"
-	"github.com/go-chi/chi/v5"
 	"github.com/sirrobot01/decypharr/internal/request"
 	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/service"
 	"net/http"
 	"path/filepath"
 	"strings"
 )
 
-func decodeAuthHeader(header string) (string, string, error) {
-	encodedTokens := strings.Split(header, " ")
-	if len(encodedTokens) != 2 {
-		return "", "", nil
-	}
-	encodedToken := encodedTokens[1]
-
-	bytes, err := base64.StdEncoding.DecodeString(encodedToken)
-	if err != nil {
-		return "", "", err
-	}
-
-	bearer := string(bytes)
-
-	colonIndex := strings.LastIndex(bearer, ":")
-	host := bearer[:colonIndex]
-	token := bearer[colonIndex+1:]
-
-	return host, token, nil
-}
-
-func (q *QBit) CategoryContext(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		category := strings.Trim(r.URL.Query().Get("category"), "")
-		if category == "" {
-			// Get from form
-			_ = r.ParseForm()
-			category = r.Form.Get("category")
-			if category == "" {
-				// Get from multipart form
-				_ = r.ParseMultipartForm(32 << 20)
-				category = r.FormValue("category")
-			}
-		}
-		ctx := context.WithValue(r.Context(), "category", strings.TrimSpace(category))
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
-func (q *QBit) authContext(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		host, token, err := decodeAuthHeader(r.Header.Get("Authorization"))
-		category := r.Context().Value("category").(string)
-		svc := service.GetService()
-		// Check if arr exists
-		a := svc.Arr.Get(category)
-		if a == nil {
-			downloadUncached := false
-			a = arr.New(category, "", "", false, false, &downloadUncached)
-		}
-		if err == nil {
-			host = strings.TrimSpace(host)
-			if host != "" {
-				a.Host = host
-			}
-			token = strings.TrimSpace(token)
-			if token != "" {
-				a.Token = token
-			}
-		}
-
-		svc.Arr.AddOrUpdate(a)
-		ctx := context.WithValue(r.Context(), "arr", a)
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
-func HashesCtx(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_hashes := chi.URLParam(r, "hashes")
-		var hashes []string
-		if _hashes != "" {
-			hashes = strings.Split(_hashes, "|")
-		}
-		if hashes == nil {
-			// Get hashes from form
-			_ = r.ParseForm()
-			hashes = r.Form["hashes"]
-		}
-		for i, hash := range hashes {
-			hashes[i] = strings.TrimSpace(hash)
-		}
-		ctx := context.WithValue(r.Context(), "hashes", hashes)
-		next.ServeHTTP(w, r.WithContext(ctx))
-	})
-}
-
 func (q *QBit) handleLogin(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	_arr := ctx.Value("arr").(*arr.Arr)
+	_arr := getArrFromContext(ctx)
 	if _arr == nil {
-		// No arr
+		// Arr not in context, return OK
 		_, _ = w.Write([]byte("Ok."))
 		return
 	}
 	if err := _arr.Validate(); err != nil {
-		q.logger.Info().Msgf("Error validating arr: %v", err)
+		q.logger.Error().Err(err).Msgf("Error validating arr")
+		http.Error(w, "Invalid arr configuration", http.StatusBadRequest)
 	}
 	_, _ = w.Write([]byte("Ok."))
 }
@@ -122,7 +32,7 @@ func (q *QBit) handleWebAPIVersion(w http.ResponseWriter, r *http.Request) {
 }
 
 func (q *QBit) handlePreferences(w http.ResponseWriter, r *http.Request) {
-	preferences := NewAppPreferences()
+	preferences := getAppPreferences()
 
 	preferences.WebUiUsername = q.Username
 	preferences.SavePath = q.DownloadFolder
@@ -150,10 +60,10 @@ func (q *QBit) handleShutdown(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentsInfo(w http.ResponseWriter, r *http.Request) {
 	//log all url params
 	ctx := r.Context()
-	category := ctx.Value("category").(string)
+	category := getCategory(ctx)
 	filter := strings.Trim(r.URL.Query().Get("filter"), "")
-	hashes, _ := ctx.Value("hashes").([]string)
-	torrents := q.Storage.GetAllSorted(category, filter, hashes, "added_on", false)
+	hashes := getHashes(ctx)
+	torrents := q.storage.GetAllSorted(category, filter, hashes, "added_on", false)
 	request.JSONResponse(w, torrents, http.StatusOK)
 }
 
@@ -164,13 +74,13 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 	contentType := r.Header.Get("Content-Type")
 	if strings.Contains(contentType, "multipart/form-data") {
 		if err := r.ParseMultipartForm(32 << 20); err != nil {
-			q.logger.Info().Msgf("Error parsing multipart form: %v", err)
+			q.logger.Error().Err(err).Msgf("Error parsing multipart form")
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
 	} else if strings.Contains(contentType, "application/x-www-form-urlencoded") {
 		if err := r.ParseForm(); err != nil {
-			q.logger.Info().Msgf("Error parsing form: %v", err)
+			q.logger.Error().Err(err).Msgf("Error parsing form")
 			http.Error(w, err.Error(), http.StatusBadRequest)
 			return
 		}
@@ -179,10 +89,18 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	isSymlink := strings.ToLower(r.FormValue("sequentialDownload")) != "true"
+	action := "symlink"
+	if strings.ToLower(r.FormValue("sequentialDownload")) == "true" {
+		action = "download"
+	}
+	debridName := r.FormValue("debrid")
 	category := r.FormValue("category")
+	_arr := getArrFromContext(ctx)
+	if _arr == nil {
+		// Arr is not in context
+		_arr = arr.New(category, "", "", false, false, nil, "", "")
+	}
 	atleastOne := false
-	ctx = context.WithValue(ctx, "isSymlink", isSymlink)
 
 	// Handle magnet URLs
 	if urls := r.FormValue("urls"); urls != "" {
@@ -191,8 +109,8 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 			urlList = append(urlList, strings.TrimSpace(u))
 		}
 		for _, url := range urlList {
-			if err := q.AddMagnet(ctx, url, category); err != nil {
-				q.logger.Info().Msgf("Error adding magnet: %v", err)
+			if err := q.addMagnet(ctx, url, _arr, debridName, action); err != nil {
+				q.logger.Debug().Msgf("Error adding magnet: %s", err.Error())
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return
 			}
@@ -204,8 +122,8 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 	if r.MultipartForm != nil && r.MultipartForm.File != nil {
 		if files := r.MultipartForm.File["torrents"]; len(files) > 0 {
 			for _, fileHeader := range files {
-				if err := q.AddTorrent(ctx, fileHeader, category); err != nil {
-					q.logger.Info().Msgf("Error adding torrent: %v", err)
+				if err := q.addTorrent(ctx, fileHeader, _arr, debridName, action); err != nil {
+					q.logger.Debug().Err(err).Msgf("Error adding torrent")
 					http.Error(w, err.Error(), http.StatusBadRequest)
 					return
 				}
@@ -224,14 +142,14 @@ func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	if len(hashes) == 0 {
 		http.Error(w, "No hashes provided", http.StatusBadRequest)
 		return
 	}
-	category := ctx.Value("category").(string)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		q.Storage.Delete(hash, category)
+		q.storage.Delete(hash, category, false)
 	}
 
 	w.WriteHeader(http.StatusOK)
@@ -239,10 +157,10 @@ func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -254,10 +172,10 @@ func (q *QBit) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -269,10 +187,10 @@ func (q *QBit) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
 
 func (q *QBit) handleTorrentRecheck(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
-	category := ctx.Value("category").(string)
+	hashes := getHashes(ctx)
+	category := getCategory(ctx)
 	for _, hash := range hashes {
-		torrent := q.Storage.Get(hash, category)
+		torrent := q.storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
@@ -315,7 +233,7 @@ func (q *QBit) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	hash := r.URL.Query().Get("hash")
-	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
+	torrent := q.storage.Get(hash, getCategory(ctx))
 
 	properties := q.GetTorrentProperties(torrent)
 	request.JSONResponse(w, properties, http.StatusOK)
@@ -324,22 +242,21 @@ func (q *QBit) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
 func (q *QBit) handleTorrentFiles(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	hash := r.URL.Query().Get("hash")
-	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
+	torrent := q.storage.Get(hash, getCategory(ctx))
 	if torrent == nil {
 		return
 	}
-	files := q.GetTorrentFiles(torrent)
-	request.JSONResponse(w, files, http.StatusOK)
+	request.JSONResponse(w, torrent.Files, http.StatusOK)
 }
 
 func (q *QBit) handleSetCategory(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
-	category := ctx.Value("category").(string)
-	hashes, _ := ctx.Value("hashes").([]string)
-	torrents := q.Storage.GetAll("", "", hashes)
+	category := getCategory(ctx)
+	hashes := getHashes(ctx)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
 		torrent.Category = category
-		q.Storage.AddOrUpdate(torrent)
+		q.storage.AddOrUpdate(torrent)
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
 }
@@ -351,14 +268,14 @@ func (q *QBit) handleAddTorrentTags(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	tags := strings.Split(r.FormValue("tags"), ",")
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.Storage.GetAll("", "", hashes)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, t := range torrents {
-		q.SetTorrentTags(t, tags)
+		q.setTorrentTags(t, tags)
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
 }
@@ -370,14 +287,14 @@ func (q *QBit) handleRemoveTorrentTags(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	ctx := r.Context()
-	hashes, _ := ctx.Value("hashes").([]string)
+	hashes := getHashes(ctx)
 	tags := strings.Split(r.FormValue("tags"), ",")
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.Storage.GetAll("", "", hashes)
+	torrents := q.storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
-		q.RemoveTorrentTags(torrent, tags)
+		q.removeTorrentTags(torrent, tags)
 
 	}
 	request.JSONResponse(w, nil, http.StatusOK)
@@ -397,6 +314,6 @@ func (q *QBit) handleCreateTags(w http.ResponseWriter, r *http.Request) {
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	q.AddTags(tags)
+	q.addTags(tags)
 	request.JSONResponse(w, nil, http.StatusOK)
 }

pkg/qbit/import.go

@@ -1,90 +0,0 @@
-package qbit
-
-import (
-	"fmt"
-	"github.com/sirrobot01/decypharr/internal/utils"
-	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
-	"github.com/sirrobot01/decypharr/pkg/service"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/sirrobot01/decypharr/pkg/arr"
-)
-
-type ImportRequest struct {
-	ID               string        `json:"id"`
-	Path             string        `json:"path"`
-	Magnet           *utils.Magnet `json:"magnet"`
-	Arr              *arr.Arr      `json:"arr"`
-	IsSymlink        bool          `json:"isSymlink"`
-	SeriesId         int           `json:"series"`
-	Seasons          []int         `json:"seasons"`
-	Episodes         []string      `json:"episodes"`
-	DownloadUncached bool          `json:"downloadUncached"`
-
-	Failed      bool      `json:"failed"`
-	FailedAt    time.Time `json:"failedAt"`
-	Reason      string    `json:"reason"`
-	Completed   bool      `json:"completed"`
-	CompletedAt time.Time `json:"completedAt"`
-	Async       bool      `json:"async"`
-}
-
-type ManualImportResponseSchema struct {
-	Priority            string    `json:"priority"`
-	Status              string    `json:"status"`
-	Result              string    `json:"result"`
-	Queued              time.Time `json:"queued"`
-	Trigger             string    `json:"trigger"`
-	SendUpdatesToClient bool      `json:"sendUpdatesToClient"`
-	UpdateScheduledTask bool      `json:"updateScheduledTask"`
-	Id                  int       `json:"id"`
-}
-
-func NewImportRequest(magnet *utils.Magnet, arr *arr.Arr, isSymlink, downloadUncached bool) *ImportRequest {
-	return &ImportRequest{
-		ID:               uuid.NewString(),
-		Magnet:           magnet,
-		Arr:              arr,
-		Failed:           false,
-		Completed:        false,
-		Async:            false,
-		IsSymlink:        isSymlink,
-		DownloadUncached: downloadUncached,
-	}
-}
-
-func (i *ImportRequest) Fail(reason string) {
-	i.Failed = true
-	i.FailedAt = time.Now()
-	i.Reason = reason
-}
-
-func (i *ImportRequest) Complete() {
-	i.Completed = true
-	i.CompletedAt = time.Now()
-}
-
-func (i *ImportRequest) Process(q *QBit) (err error) {
-	// Use this for now.
-	// This sends the torrent to the arr
-	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")
-		}
-		return err
-	}
-	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-	q.Storage.AddOrUpdate(torrent)
-	go q.ProcessFiles(torrent, debridTorrent, i.Arr, i.IsSymlink)
-	return nil
-}

pkg/qbit/qbit.go

@@ -1,41 +1,38 @@
 package qbit
 
 import (
-	"cmp"
 	"github.com/rs/zerolog"
 	"github.com/sirrobot01/decypharr/internal/config"
 	"github.com/sirrobot01/decypharr/internal/logger"
-	"os"
-	"path/filepath"
+	"github.com/sirrobot01/decypharr/pkg/store"
 )
 
 type QBit struct {
-	Username        string   `json:"username"`
-	Password        string   `json:"password"`
-	Port            string   `json:"port"`
-	DownloadFolder  string   `json:"download_folder"`
-	Categories      []string `json:"categories"`
-	Storage         *TorrentStorage
-	logger          zerolog.Logger
-	Tags            []string
-	RefreshInterval int
-	SkipPreCache    bool
+	Username       string
+	Password       string
+	DownloadFolder string
+	Categories     []string
+	storage        *store.TorrentStorage
+	logger         zerolog.Logger
+	Tags           []string
 }
 
 func New() *QBit {
 	_cfg := config.Get()
 	cfg := _cfg.QBitTorrent
-	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,
+		DownloadFolder: cfg.DownloadFolder,
+		Categories:     cfg.Categories,
+		storage:        store.Get().Torrents(),
+		logger:         logger.New("qbit"),
 	}
 }
+
+func (q *QBit) Reset() {
+	if q.storage != nil {
+		q.storage.Reset()
+	}
+	q.Tags = nil
+}

pkg/qbit/routes.go

@@ -7,12 +7,12 @@ import (
 
 func (q *QBit) Routes() http.Handler {
 	r := chi.NewRouter()
-	r.Use(q.CategoryContext)
+	r.Use(q.categoryContext)
 	r.Group(func(r chi.Router) {
 		r.Use(q.authContext)
 		r.Post("/auth/login", q.handleLogin)
 		r.Route("/torrents", func(r chi.Router) {
-			r.Use(HashesCtx)
+			r.Use(hashesContext)
 			r.Get("/info", q.handleTorrentsInfo)
 			r.Post("/add", q.handleTorrentsAdd)
 			r.Post("/delete", q.handleTorrentsDelete)

pkg/qbit/torrent.go

@@ -1,39 +1,35 @@
 package qbit
 
 import (
-	"cmp"
 	"context"
 	"fmt"
-	"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/service"
+	"github.com/sirrobot01/decypharr/pkg/store"
 	"io"
 	"mime/multipart"
-	"os"
-	"path/filepath"
-	"slices"
 	"strings"
 	"time"
 )
 
-// All torrent related helpers goes here
-
-func (q *QBit) AddMagnet(ctx context.Context, url, category string) error {
+// All torrent-related helpers goes here
+func (q *QBit) addMagnet(ctx context.Context, url string, arr *arr.Arr, debrid string, action string) error {
 	magnet, err := utils.GetMagnetFromUrl(url)
 	if err != nil {
 		return fmt.Errorf("error parsing magnet link: %w", err)
 	}
-	err = q.Process(ctx, magnet, category)
+	_store := store.Get()
+
+	importReq := store.NewImportRequest(debrid, q.DownloadFolder, magnet, arr, action, false, "", store.ImportTypeQBitTorrent)
+
+	err = _store.AddTorrent(ctx, importReq)
 	if err != nil {
 		return fmt.Errorf("failed to process torrent: %w", err)
 	}
 	return nil
 }
 
-func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader, category string) error {
+func (q *QBit) addTorrent(ctx context.Context, fileHeader *multipart.FileHeader, arr *arr.Arr, debrid string, action string) error {
 	file, _ := fileHeader.Open()
 	defer file.Close()
 	var reader io.Reader = file
@@ -41,227 +37,28 @@ func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader,
 	if err != nil {
 		return fmt.Errorf("error reading file: %s \n %w", fileHeader.Filename, err)
 	}
-	err = q.Process(ctx, magnet, category)
+	_store := store.Get()
+	importReq := store.NewImportRequest(debrid, q.DownloadFolder, magnet, arr, action, false, "", store.ImportTypeQBitTorrent)
+	err = _store.AddTorrent(ctx, importReq)
 	if err != nil {
 		return fmt.Errorf("failed to process torrent: %w", err)
 	}
 	return nil
 }
 
-func (q *QBit) Process(ctx context.Context, magnet *utils.Magnet, category string) error {
-	svc := service.GetService()
-	torrent := createTorrentFromMagnet(magnet, category, "auto")
-	a, ok := ctx.Value("arr").(*arr.Arr)
-	if !ok {
-		return fmt.Errorf("arr not found in context")
-	}
-	isSymlink := ctx.Value("isSymlink").(bool)
-	debridTorrent, err := db.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")
-		}
-		return err
-	}
-	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-	q.Storage.AddOrUpdate(torrent)
-	go q.ProcessFiles(torrent, debridTorrent, a, isSymlink) // We can send async for file processing not to delay the response
-	return nil
-}
-
-func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr *arr.Arr, isSymlink bool) {
-	svc := service.GetService()
-	client := svc.Debrid.GetByName(debridTorrent.Debrid)
-	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 {
-			q.logger.Error().Msgf("Error checking status: %v", err)
-			go func() {
-				err := client.DeleteTorrent(debridTorrent.Id)
-				if err != nil {
-					q.logger.Error().Msgf("Error deleting torrent: %v", err)
-				}
-			}()
-			q.MarkAsFailed(torrent)
-			if err := arr.Refresh(); err != nil {
-				q.logger.Error().Msgf("Error refreshing arr: %v", err)
-			}
-			return
-		}
-
-		debridTorrent = dbT
-		torrent = q.UpdateTorrentMin(torrent, debridTorrent)
-
-		// Exit the loop for downloading statuses to prevent memory buildup
-		if !slices.Contains(client.GetDownloadingStatus(), debridTorrent.Status) {
-			break
-		}
-		time.Sleep(time.Duration(q.RefreshInterval) * time.Second)
-	}
-	var (
-		torrentSymlinkPath string
-		err                error
-	)
-	debridTorrent.Arr = arr
-
-	// File is done downloading at this stage
-
-	// Check if debrid supports webdav by checking cache
-	if isSymlink {
-		cache, ok := svc.Debrid.Caches[debridTorrent.Debrid]
-		if ok {
-			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/
-
-		} else {
-			// User is using either zurg or debrid webdav
-			torrentSymlinkPath, err = q.ProcessSymlink(torrent) // /mnt/symlinks/{category}/MyTVShow/
-		}
-	} else {
-		torrentSymlinkPath, err = q.ProcessManualFile(torrent)
-	}
-	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)
-			}
-		}()
-		q.logger.Info().Msgf("Error: %v", err)
-		return
-	}
-	torrent.TorrentPath = torrentSymlinkPath
-	q.UpdateTorrent(torrent, debridTorrent)
-	go func() {
-		if err := request.SendDiscordMessage("download_complete", "success", torrent.discordContext()); err != nil {
-			q.logger.Error().Msgf("Error sending discord message: %v", err)
-		}
-	}()
-	if err := arr.Refresh(); err != nil {
-		q.logger.Error().Msgf("Error refreshing arr: %v", err)
-	}
-}
-
-func (q *QBit) MarkAsFailed(t *Torrent) *Torrent {
-	t.State = "error"
-	q.Storage.AddOrUpdate(t)
-	go func() {
-		if err := request.SendDiscordMessage("download_failed", "error", t.discordContext()); err != nil {
-			q.logger.Error().Msgf("Error sending discord message: %v", err)
-		}
-	}()
-	return t
-}
-
-func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
-	if debridTorrent == nil {
-		return t
-	}
-
-	addedOn, err := time.Parse(time.RFC3339, debridTorrent.Added)
-	if err != nil {
-		addedOn = time.Now()
-	}
-	totalSize := debridTorrent.Bytes
-	progress := cmp.Or(debridTorrent.Progress, 100)
-	progress = progress / 100.0
-	sizeCompleted := int64(float64(totalSize) * progress)
-
-	var speed int64
-	if debridTorrent.Speed != 0 {
-		speed = debridTorrent.Speed
-	}
-	var eta int
-	if speed != 0 {
-		eta = int((totalSize - sizeCompleted) / speed)
-	}
-	t.ID = debridTorrent.Id
-	t.Name = debridTorrent.Name
-	t.AddedOn = addedOn.Unix()
-	t.DebridTorrent = debridTorrent
-	t.Debrid = debridTorrent.Debrid
-	t.Size = totalSize
-	t.Completed = sizeCompleted
-	t.Downloaded = sizeCompleted
-	t.DownloadedSession = sizeCompleted
-	t.Uploaded = sizeCompleted
-	t.UploadedSession = sizeCompleted
-	t.AmountLeft = totalSize - sizeCompleted
-	t.Progress = progress
-	t.Eta = eta
-	t.Dlspeed = speed
-	t.Upspeed = speed
-	t.SavePath = filepath.Join(q.DownloadFolder, t.Category) + string(os.PathSeparator)
-	t.ContentPath = filepath.Join(t.SavePath, t.Name) + string(os.PathSeparator)
-	return t
-}
-
-func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
-	if debridTorrent == nil {
-		return t
-	}
-	_db := service.GetDebrid().GetByName(debridTorrent.Debrid)
-	if debridTorrent.Status != "downloaded" {
-		_ = _db.UpdateTorrent(debridTorrent)
-	}
-	t = q.UpdateTorrentMin(t, debridTorrent)
-	t.ContentPath = t.TorrentPath + string(os.PathSeparator)
-
-	if t.IsReady() {
-		t.State = "pausedUP"
-		q.Storage.Update(t)
-		return t
-	}
-
-	ticker := time.NewTicker(100 * time.Millisecond)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if t.IsReady() {
-				t.State = "pausedUP"
-				q.Storage.Update(t)
-				return t
-			}
-			updatedT := q.UpdateTorrent(t, debridTorrent)
-			t = updatedT
-
-		case <-time.After(10 * time.Minute): // Add a timeout
-			return t
-		}
-	}
-}
-
-func (q *QBit) ResumeTorrent(t *Torrent) bool {
+func (q *QBit) ResumeTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) PauseTorrent(t *Torrent) bool {
+func (q *QBit) PauseTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) RefreshTorrent(t *Torrent) bool {
+func (q *QBit) RefreshTorrent(t *store.Torrent) bool {
 	return true
 }
 
-func (q *QBit) GetTorrentProperties(t *Torrent) *TorrentProperties {
+func (q *QBit) GetTorrentProperties(t *store.Torrent) *TorrentProperties {
 	return &TorrentProperties{
 		AdditionDate:           t.AddedOn,
 		Comment:                "Debrid Blackhole <https://github.com/sirrobot01/decypharr>",
@@ -286,60 +83,41 @@ func (q *QBit) GetTorrentProperties(t *Torrent) *TorrentProperties {
 	}
 }
 
-func (q *QBit) GetTorrentFiles(t *Torrent) []*TorrentFile {
-	files := make([]*TorrentFile, 0)
-	if t.DebridTorrent == nil {
-		return files
-	}
-	for _, file := range t.DebridTorrent.Files {
-		files = append(files, &TorrentFile{
-			Name: file.Path,
-			Size: file.Size,
-		})
-	}
-	return files
-}
-
-func (q *QBit) SetTorrentTags(t *Torrent, tags []string) bool {
+func (q *QBit) setTorrentTags(t *store.Torrent, tags []string) bool {
 	torrentTags := strings.Split(t.Tags, ",")
 	for _, tag := range tags {
 		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)
 		}
 	}
 	t.Tags = strings.Join(torrentTags, ",")
-	q.Storage.Update(t)
+	q.storage.Update(t)
 	return true
 }
 
-func (q *QBit) RemoveTorrentTags(t *Torrent, tags []string) bool {
+func (q *QBit) removeTorrentTags(t *store.Torrent, tags []string) bool {
 	torrentTags := strings.Split(t.Tags, ",")
 	newTorrentTags := utils.RemoveItem(torrentTags, tags...)
 	q.Tags = utils.RemoveItem(q.Tags, tags...)
 	t.Tags = strings.Join(newTorrentTags, ",")
-	q.Storage.Update(t)
+	q.storage.Update(t)
 	return true
 }
 
-func (q *QBit) AddTags(tags []string) bool {
+func (q *QBit) addTags(tags []string) bool {
 	for _, tag := range tags {
 		if tag == "" {
 			continue
 		}
-		if !slices.Contains(q.Tags, tag) {
+		if !utils.Contains(q.Tags, tag) {
 			q.Tags = append(q.Tags, tag)
 		}
 	}
 	return true
 }
-
-func (q *QBit) RemoveTags(tags []string) bool {
-	q.Tags = utils.RemoveItem(q.Tags, tags...)
-	return true
-}

pkg/qbit/types.go

@@ -1,11 +1,5 @@
 package qbit
 
-import (
-	"fmt"
-	"github.com/sirrobot01/decypharr/pkg/debrid/types"
-	"sync"
-)
-
 type BuildInfo struct {
 	Libtorrent string `json:"libtorrent"`
 	Bitness    int    `json:"bitness"`
@@ -172,76 +166,6 @@ type TorrentCategory struct {
 	SavePath string `json:"savePath"`
 }
 
-type Torrent struct {
-	ID            string         `json:"id"`
-	DebridTorrent *types.Torrent `json:"-"`
-	Debrid        string         `json:"debrid"`
-	TorrentPath   string         `json:"-"`
-
-	AddedOn           int64   `json:"added_on,omitempty"`
-	AmountLeft        int64   `json:"amount_left"`
-	AutoTmm           bool    `json:"auto_tmm"`
-	Availability      float64 `json:"availability,omitempty"`
-	Category          string  `json:"category,omitempty"`
-	Completed         int64   `json:"completed"`
-	CompletionOn      int     `json:"completion_on,omitempty"`
-	ContentPath       string  `json:"content_path"`
-	DlLimit           int     `json:"dl_limit"`
-	Dlspeed           int64   `json:"dlspeed"`
-	Downloaded        int64   `json:"downloaded"`
-	DownloadedSession int64   `json:"downloaded_session"`
-	Eta               int     `json:"eta"`
-	FlPiecePrio       bool    `json:"f_l_piece_prio,omitempty"`
-	ForceStart        bool    `json:"force_start,omitempty"`
-	Hash              string  `json:"hash"`
-	LastActivity      int64   `json:"last_activity,omitempty"`
-	MagnetUri         string  `json:"magnet_uri,omitempty"`
-	MaxRatio          int     `json:"max_ratio,omitempty"`
-	MaxSeedingTime    int     `json:"max_seeding_time,omitempty"`
-	Name              string  `json:"name,omitempty"`
-	NumComplete       int     `json:"num_complete,omitempty"`
-	NumIncomplete     int     `json:"num_incomplete,omitempty"`
-	NumLeechs         int     `json:"num_leechs,omitempty"`
-	NumSeeds          int     `json:"num_seeds,omitempty"`
-	Priority          int     `json:"priority,omitempty"`
-	Progress          float64 `json:"progress"`
-	Ratio             int     `json:"ratio,omitempty"`
-	RatioLimit        int     `json:"ratio_limit,omitempty"`
-	SavePath          string  `json:"save_path"`
-	SeedingTimeLimit  int     `json:"seeding_time_limit,omitempty"`
-	SeenComplete      int64   `json:"seen_complete,omitempty"`
-	SeqDl             bool    `json:"seq_dl"`
-	Size              int64   `json:"size,omitempty"`
-	State             string  `json:"state,omitempty"`
-	SuperSeeding      bool    `json:"super_seeding"`
-	Tags              string  `json:"tags,omitempty"`
-	TimeActive        int     `json:"time_active,omitempty"`
-	TotalSize         int64   `json:"total_size,omitempty"`
-	Tracker           string  `json:"tracker,omitempty"`
-	UpLimit           int64   `json:"up_limit,omitempty"`
-	Uploaded          int64   `json:"uploaded,omitempty"`
-	UploadedSession   int64   `json:"uploaded_session,omitempty"`
-	Upspeed           int64   `json:"upspeed,omitempty"`
-	Source            string  `json:"source,omitempty"`
-
-	Mu sync.Mutex `json:"-"`
-}
-
-func (t *Torrent) IsReady() bool {
-	return t.AmountLeft <= 0 && t.TorrentPath != ""
-}
-
-func (t *Torrent) discordContext() string {
-	format := `
-		**Name:** %s
-		**Arr:** %s
-		**Hash:** %s
-		**MagnetURI:** %s
-		**Debrid:** %s
-	`
-	return fmt.Sprintf(format, t.Name, t.Category, t.Hash, t.MagnetUri, t.Debrid)
-}
-
 type TorrentProperties struct {
 	AdditionDate           int64  `json:"addition_date,omitempty"`
 	Comment                string `json:"comment,omitempty"`
@@ -278,18 +202,7 @@ type TorrentProperties struct {
 	UpSpeedAvg             int    `json:"up_speed_avg,omitempty"`
 }
 
-type TorrentFile struct {
-	Index        int     `json:"index,omitempty"`
-	Name         string  `json:"name,omitempty"`
-	Size         int64   `json:"size,omitempty"`
-	Progress     int     `json:"progress,omitempty"`
-	Priority     int     `json:"priority,omitempty"`
-	IsSeed       bool    `json:"is_seed,omitempty"`
-	PieceRange   []int   `json:"piece_range,omitempty"`
-	Availability float64 `json:"availability,omitempty"`
-}
-
-func NewAppPreferences() *AppPreferences {
+func getAppPreferences() *AppPreferences {
 	preferences := &AppPreferences{
 		AddTrackers:                        "",
 		AddTrackersEnabled:                 false,

pkg/rar/rarar.go

@@ -0,0 +1,701 @@
+// Source: https://github.com/eliasbenb/RARAR.py
+// Note that this code only translates the original Python for RAR3 (not RAR5) support.
+
+package rar
+
+import (
+	"bytes"
+	"encoding/binary"
+	"errors"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"strings"
+	"time"
+	"unicode/utf8"
+)
+
+// Constants from the Python code
+var (
+	// Chunk sizes
+	DefaultChunkSize = 4096
+	HttpChunkSize    = 32768
+	MaxSearchSize    = 1 << 20 // 1MB
+
+	// RAR marker and block types
+	Rar3Marker  = []byte{0x52, 0x61, 0x72, 0x21, 0x1A, 0x07, 0x00}
+	BlockFile   = byte(0x74)
+	BlockHeader = byte(0x73)
+	BlockMarker = byte(0x72)
+	BlockEnd    = byte(0x7B)
+
+	// Header flags
+	FlagDirectory      = 0xE0
+	FlagHasHighSize    = 0x100
+	FlagHasUnicodeName = 0x200
+	FlagHasData        = 0x8000
+)
+
+// Compression methods
+var CompressionMethods = map[byte]string{
+	0x30: "Store",
+	0x31: "Fastest",
+	0x32: "Fast",
+	0x33: "Normal",
+	0x34: "Good",
+	0x35: "Best",
+}
+
+// Error definitions
+var (
+	ErrMarkerNotFound               = errors.New("RAR marker not found within search limit")
+	ErrInvalidFormat                = errors.New("invalid RAR format")
+	ErrNetworkError                 = errors.New("network error")
+	ErrRangeRequestsNotSupported    = errors.New("server does not support range requests")
+	ErrCompressionNotSupported      = errors.New("compression method not supported")
+	ErrDirectoryExtractNotSupported = errors.New("directory extract not supported")
+)
+
+// Name returns the base filename of the file
+func (f *File) Name() string {
+	if i := strings.LastIndexAny(f.Path, "\\/"); i >= 0 {
+		return f.Path[i+1:]
+	}
+	return f.Path
+}
+
+func (f *File) ByteRange() *[2]int64 {
+	return &[2]int64{f.DataOffset, f.DataOffset + f.CompressedSize - 1}
+}
+
+func NewHttpFile(url string) (*HttpFile, error) {
+	client := &http.Client{}
+	file := &HttpFile{
+		URL:        url,
+		Position:   0,
+		Client:     client,
+		MaxRetries: 3,
+		RetryDelay: time.Second,
+	}
+
+	// Get file size
+	size, err := file.getFileSize()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get file size: %w", err)
+	}
+	file.FileSize = size
+
+	return file, nil
+}
+
+func (f *HttpFile) doWithRetry(operation func() (interface{}, error)) (interface{}, error) {
+	var lastErr error
+	for attempt := 0; attempt <= f.MaxRetries; attempt++ {
+		if attempt > 0 {
+			// Jitter + exponential backoff delay
+			delay := f.RetryDelay * time.Duration(1<<uint(attempt-1))
+			jitter := time.Duration(rand.Int63n(int64(delay / 4)))
+			time.Sleep(delay + jitter)
+		}
+
+		result, err := operation()
+		if err == nil {
+			return result, nil
+		}
+
+		lastErr = err
+		// Only retry on network errors
+		if !errors.Is(err, ErrNetworkError) {
+			return nil, err
+		}
+	}
+
+	return nil, fmt.Errorf("after %d retries: %w", f.MaxRetries, lastErr)
+}
+
+// getFileSize gets the total file size from the server
+func (f *HttpFile) getFileSize() (int64, error) {
+	result, err := f.doWithRetry(func() (interface{}, error) {
+		resp, err := f.Client.Head(f.URL)
+		if err != nil {
+			return int64(0), fmt.Errorf("%w: %v", ErrNetworkError, err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return int64(0), fmt.Errorf("%w: unexpected status code: %d", ErrNetworkError, resp.StatusCode)
+		}
+
+		contentLength := resp.Header.Get("Content-Length")
+		if contentLength == "" {
+			return int64(0), fmt.Errorf("%w: content length not provided", ErrNetworkError)
+		}
+
+		var size int64
+		_, err = fmt.Sscanf(contentLength, "%d", &size)
+		if err != nil {
+			return int64(0), fmt.Errorf("%w: %v", ErrNetworkError, err)
+		}
+
+		return size, nil
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	return result.(int64), nil
+}
+
+// ReadAt implements the io.ReaderAt interface
+func (f *HttpFile) ReadAt(p []byte, off int64) (n int, err error) {
+	if len(p) == 0 {
+		return 0, nil
+	}
+
+	// Ensure we don't read past the end of the file
+	size := int64(len(p))
+	if f.FileSize > 0 {
+		remaining := f.FileSize - off
+		if remaining <= 0 {
+			return 0, io.EOF
+		}
+		if size > remaining {
+			size = remaining
+			p = p[:size]
+		}
+	}
+
+	result, err := f.doWithRetry(func() (interface{}, error) {
+		// Create HTTP request with Range header
+		req, err := http.NewRequest("GET", f.URL, nil)
+		if err != nil {
+			return 0, fmt.Errorf("%w: %v", ErrNetworkError, err)
+		}
+
+		end := off + size - 1
+		req.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", off, end))
+
+		// Make the request
+		resp, err := f.Client.Do(req)
+		if err != nil {
+			return 0, fmt.Errorf("%w: %v", ErrNetworkError, err)
+		}
+		defer resp.Body.Close()
+
+		// Handle response
+		switch resp.StatusCode {
+		case http.StatusPartialContent:
+			// Read the content
+			bytesRead, err := io.ReadFull(resp.Body, p)
+			return bytesRead, err
+		case http.StatusOK:
+			// Some servers return the full content instead of partial
+			fullData, err := io.ReadAll(resp.Body)
+			if err != nil {
+				return 0, fmt.Errorf("%w: %v", ErrNetworkError, err)
+			}
+
+			if int64(len(fullData)) <= off {
+				return 0, io.EOF
+			}
+
+			end = off + size
+			if int64(len(fullData)) < end {
+				end = int64(len(fullData))
+			}
+
+			copy(p, fullData[off:end])
+			return int(end - off), nil
+		case http.StatusRequestedRangeNotSatisfiable:
+			// We're at EOF
+			return 0, io.EOF
+		default:
+			return 0, fmt.Errorf("%w: unexpected status code: %d", ErrNetworkError, resp.StatusCode)
+		}
+	})
+
+	if err != nil {
+		return 0, err
+	}
+
+	return result.(int), nil
+}
+
+// NewReader creates a new RAR3 reader
+func NewReader(url string) (*Reader, error) {
+	file, err := NewHttpFile(url)
+	if err != nil {
+		return nil, err
+	}
+
+	reader := &Reader{
+		File:      file,
+		ChunkSize: HttpChunkSize,
+		Files:     make([]*File, 0),
+	}
+
+	// Find RAR marker
+	marker, err := reader.findMarker()
+	if err != nil {
+		return nil, err
+	}
+	reader.Marker = marker
+	pos := reader.Marker + int64(len(Rar3Marker)) // Skip marker block
+
+	headerData, err := reader.readBytes(pos, 7)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(headerData) < 7 {
+		return nil, ErrInvalidFormat
+	}
+
+	headType := headerData[2]
+	headSize := int(binary.LittleEndian.Uint16(headerData[5:7]))
+
+	if headType != BlockHeader {
+		return nil, ErrInvalidFormat
+	}
+
+	// Store the position after the archive header
+	reader.HeaderEndPos = pos + int64(headSize)
+
+	return reader, nil
+}
+
+// readBytes reads a range of bytes from the file
+func (r *Reader) readBytes(start int64, length int) ([]byte, error) {
+	if length <= 0 {
+		return []byte{}, nil
+	}
+
+	data := make([]byte, length)
+	n, err := r.File.ReadAt(data, start)
+	if err != nil && err != io.EOF {
+		return nil, err
+	}
+
+	if n < length {
+		// Partial read, return what we got
+		return data[:n], nil
+	}
+
+	return data, nil
+}
+
+// findMarker finds the RAR marker in the file
+func (r *Reader) findMarker() (int64, error) {
+	// First try to find marker in the first chunk
+	firstChunkSize := 8192 // 8KB
+	chunk, err := r.readBytes(0, firstChunkSize)
+	if err != nil {
+		return 0, err
+	}
+
+	markerPos := bytes.Index(chunk, Rar3Marker)
+	if markerPos != -1 {
+		return int64(markerPos), nil
+	}
+
+	// If not found, continue searching
+	position := int64(firstChunkSize - len(Rar3Marker) + 1)
+	maxSearch := int64(MaxSearchSize)
+
+	for position < maxSearch {
+		chunkSize := min(r.ChunkSize, int(maxSearch-position))
+		chunk, err := r.readBytes(position, chunkSize)
+		if err != nil || len(chunk) == 0 {
+			break
+		}
+
+		markerPos := bytes.Index(chunk, Rar3Marker)
+		if markerPos != -1 {
+			return position + int64(markerPos), nil
+		}
+
+		// Move forward by chunk size minus the marker length
+		position += int64(max(1, len(chunk)-len(Rar3Marker)+1))
+	}
+
+	return 0, ErrMarkerNotFound
+}
+
+// decodeUnicode decodes RAR3 Unicode encoding
+func decodeUnicode(asciiStr string, unicodeData []byte) string {
+	if len(unicodeData) == 0 {
+		return asciiStr
+	}
+
+	result := []rune{}
+	asciiPos := 0
+	dataPos := 0
+	highByte := byte(0)
+
+	for dataPos < len(unicodeData) {
+		flags := unicodeData[dataPos]
+		dataPos++
+
+		// Determine the number of character positions this flag byte controls
+		var flagBits uint
+		var flagCount int
+		var bitCount int
+
+		if flags&0x80 != 0 {
+			// Extended flag - controls up to 32 characters (16 bit pairs)
+			flagBits = uint(flags)
+			bitCount = 1
+			for (flagBits&(0x80>>bitCount) != 0) && dataPos < len(unicodeData) {
+				flagBits = ((flagBits & ((0x80 >> bitCount) - 1)) << 8) | uint(unicodeData[dataPos])
+				dataPos++
+				bitCount++
+			}
+			flagCount = bitCount * 4
+		} else {
+			// Simple flag - controls 4 characters (4 bit pairs)
+			flagBits = uint(flags)
+			flagCount = 4
+		}
+
+		// Process each 2-bit flag
+		for i := 0; i < flagCount; i++ {
+			if asciiPos >= len(asciiStr) && dataPos >= len(unicodeData) {
+				break
+			}
+
+			flagValue := (flagBits >> (i * 2)) & 0x03
+
+			switch flagValue {
+			case 0:
+				// Use ASCII character
+				if asciiPos < len(asciiStr) {
+					result = append(result, rune(asciiStr[asciiPos]))
+					asciiPos++
+				}
+			case 1:
+				// Unicode character with high byte 0
+				if dataPos < len(unicodeData) {
+					result = append(result, rune(unicodeData[dataPos]))
+					dataPos++
+				}
+			case 2:
+				// Unicode character with current high byte
+				if dataPos < len(unicodeData) {
+					lowByte := uint(unicodeData[dataPos])
+					dataPos++
+					result = append(result, rune(lowByte|(uint(highByte)<<8)))
+				}
+			case 3:
+				// Set new high byte
+				if dataPos < len(unicodeData) {
+					highByte = unicodeData[dataPos]
+					dataPos++
+				}
+			}
+		}
+	}
+
+	// Append any remaining ASCII characters
+	for asciiPos < len(asciiStr) {
+		result = append(result, rune(asciiStr[asciiPos]))
+		asciiPos++
+	}
+
+	return string(result)
+}
+
+// readFiles reads all file entries in the archive
+func (r *Reader) readFiles() error {
+	pos := r.Marker
+	pos += int64(len(Rar3Marker)) // Skip marker block
+
+	// Read archive header
+	headerData, err := r.readBytes(pos, 7)
+	if err != nil {
+		return err
+	}
+
+	if len(headerData) < 7 {
+		return ErrInvalidFormat
+	}
+
+	headType := headerData[2]
+	headSize := int(binary.LittleEndian.Uint16(headerData[5:7]))
+
+	if headType != BlockHeader {
+		return ErrInvalidFormat
+	}
+
+	pos += int64(headSize) // Skip archive header
+
+	// Track whether we've found the end marker
+	foundEndMarker := false
+
+	// Process file entries
+	for !foundEndMarker {
+		headerData, err := r.readBytes(pos, 7)
+		if err != nil {
+			// Don't stop on EOF, might be temporary network error
+			// For definitive errors, return the error
+			if !errors.Is(err, io.EOF) && !errors.Is(err, ErrNetworkError) {
+				return fmt.Errorf("error reading block header: %w", err)
+			}
+
+			// If we get EOF or network error, retry a few times
+			retryCount := 0
+			maxRetries := 3
+			retryDelay := time.Second
+
+			for retryCount < maxRetries {
+				time.Sleep(retryDelay * time.Duration(1<<uint(retryCount)))
+				retryCount++
+
+				headerData, err = r.readBytes(pos, 7)
+				if err == nil && len(headerData) >= 7 {
+					break // Successfully got data
+				}
+			}
+
+			if len(headerData) < 7 {
+				return fmt.Errorf("failed to read block header after retries: %w", err)
+			}
+		}
+
+		if len(headerData) < 7 {
+			return fmt.Errorf("incomplete block header at position %d", pos)
+		}
+
+		headType := headerData[2]
+		headFlags := int(binary.LittleEndian.Uint16(headerData[3:5]))
+		headSize := int(binary.LittleEndian.Uint16(headerData[5:7]))
+
+		if headType == BlockEnd {
+			// End of archive
+			foundEndMarker = true
+			break
+		}
+
+		if headType == BlockFile {
+			// Get complete header data
+			completeHeader, err := r.readBytes(pos, headSize)
+			if err != nil || len(completeHeader) < headSize {
+				// Retry logic for incomplete headers
+				retryCount := 0
+				maxRetries := 3
+				retryDelay := time.Second
+
+				for retryCount < maxRetries && (err != nil || len(completeHeader) < headSize) {
+					time.Sleep(retryDelay * time.Duration(1<<uint(retryCount)))
+					retryCount++
+
+					completeHeader, err = r.readBytes(pos, headSize)
+					if err == nil && len(completeHeader) >= headSize {
+						break // Successfully got data
+					}
+				}
+
+				if len(completeHeader) < headSize {
+					return fmt.Errorf("failed to read complete file header after retries: %w", err)
+				}
+			}
+
+			fileInfo, err := r.parseFileHeader(completeHeader, pos)
+			if err == nil && fileInfo != nil {
+				r.Files = append(r.Files, fileInfo)
+				pos = fileInfo.NextOffset
+			} else {
+				pos += int64(headSize)
+			}
+		} else {
+			// Skip non-file block
+			pos += int64(headSize)
+
+			// Skip data if present
+			if headFlags&FlagHasData != 0 {
+				// Read data size
+				sizeData, err := r.readBytes(pos-4, 4)
+				if err != nil || len(sizeData) < 4 {
+					// Retry logic for data size read errors
+					retryCount := 0
+					maxRetries := 3
+					retryDelay := time.Second
+
+					for retryCount < maxRetries && (err != nil || len(sizeData) < 4) {
+						time.Sleep(retryDelay * time.Duration(1<<uint(retryCount)))
+						retryCount++
+
+						sizeData, err = r.readBytes(pos-4, 4)
+						if err == nil && len(sizeData) >= 4 {
+							break // Successfully got data
+						}
+					}
+
+					if len(sizeData) < 4 {
+						return fmt.Errorf("failed to read data size after retries: %w", err)
+					}
+				}
+
+				dataSize := int64(binary.LittleEndian.Uint32(sizeData))
+				pos += dataSize
+			}
+		}
+	}
+
+	if !foundEndMarker {
+		return fmt.Errorf("end marker not found in archive")
+	}
+
+	return nil
+}
+
+// parseFileHeader parses a file header and returns file info
+func (r *Reader) parseFileHeader(headerData []byte, position int64) (*File, error) {
+	if len(headerData) < 7 {
+		return nil, fmt.Errorf("header data too short")
+	}
+
+	headType := headerData[2]
+	headFlags := int(binary.LittleEndian.Uint16(headerData[3:5]))
+	headSize := int(binary.LittleEndian.Uint16(headerData[5:7]))
+
+	if headType != BlockFile {
+		return nil, fmt.Errorf("not a file block")
+	}
+
+	// Check if we have enough data
+	if len(headerData) < 32 {
+		return nil, fmt.Errorf("file header too short")
+	}
+
+	// Parse basic file header fields
+	packSize := binary.LittleEndian.Uint32(headerData[7:11])
+	unpackSize := binary.LittleEndian.Uint32(headerData[11:15])
+	// fileOS := headerData[15]
+	fileCRC := binary.LittleEndian.Uint32(headerData[16:20])
+	// fileTime := binary.LittleEndian.Uint32(headerData[20:24])
+	// unpVer := headerData[24]
+	method := headerData[25]
+	nameSize := binary.LittleEndian.Uint16(headerData[26:28])
+	// fileAttr := binary.LittleEndian.Uint32(headerData[28:32])
+
+	// Handle high pack/unp sizes
+	highPackSize := uint32(0)
+	highUnpSize := uint32(0)
+
+	offset := 32 // Start after basic header fields
+
+	if headFlags&FlagHasHighSize != 0 {
+		if offset+8 <= len(headerData) {
+			highPackSize = binary.LittleEndian.Uint32(headerData[offset : offset+4])
+			highUnpSize = binary.LittleEndian.Uint32(headerData[offset+4 : offset+8])
+		}
+		offset += 8
+	}
+
+	// Calculate actual sizes
+	fullPackSize := int64(packSize) + (int64(highPackSize) << 32)
+	fullUnpSize := int64(unpackSize) + (int64(highUnpSize) << 32)
+
+	// Read filename
+	var fileName string
+	if offset+int(nameSize) <= len(headerData) {
+		fileNameBytes := headerData[offset : offset+int(nameSize)]
+
+		if headFlags&FlagHasUnicodeName != 0 {
+			zeroPos := bytes.IndexByte(fileNameBytes, 0)
+			if zeroPos != -1 {
+				// Try UTF-8 first
+				asciiPart := fileNameBytes[:zeroPos]
+				if utf8.Valid(asciiPart) {
+					fileName = string(asciiPart)
+				} else {
+					// Fall back to custom decoder
+					asciiStr := string(asciiPart)
+					unicodePart := fileNameBytes[zeroPos+1:]
+					fileName = decodeUnicode(asciiStr, unicodePart)
+				}
+			} else {
+				// No null byte
+				if utf8.Valid(fileNameBytes) {
+					fileName = string(fileNameBytes)
+				} else {
+					fileName = string(fileNameBytes) // Last resort
+				}
+			}
+		} else {
+			// Non-Unicode filename
+			if utf8.Valid(fileNameBytes) {
+				fileName = string(fileNameBytes)
+			} else {
+				fileName = string(fileNameBytes) // Fallback
+			}
+		}
+	} else {
+		fileName = fmt.Sprintf("UnknownFile%d", len(r.Files))
+	}
+
+	isDirectory := (headFlags & FlagDirectory) == FlagDirectory
+
+	// Calculate data offsets
+	dataOffset := position + int64(headSize)
+	nextOffset := dataOffset
+
+	// Only add data size if it's not a directory and has data
+	if !isDirectory && headFlags&FlagHasData != 0 {
+		nextOffset += fullPackSize
+	}
+
+	return &File{
+		Path:           fileName,
+		Size:           fullUnpSize,
+		CompressedSize: fullPackSize,
+		Method:         method,
+		CRC:            fileCRC,
+		IsDirectory:    isDirectory,
+		DataOffset:     dataOffset,
+		NextOffset:     nextOffset,
+	}, nil
+}
+
+// GetFiles returns all files in the archive
+func (r *Reader) GetFiles() ([]*File, error) {
+	if len(r.Files) == 0 {
+		err := r.readFiles()
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return r.Files, nil
+}
+
+// ExtractFile extracts a file from the archive
+func (r *Reader) ExtractFile(file *File) ([]byte, error) {
+	if file.IsDirectory {
+		return nil, ErrDirectoryExtractNotSupported
+	}
+
+	// Only support "Store" method
+	if file.Method != 0x30 { // 0x30 = "Store"
+		return nil, ErrCompressionNotSupported
+	}
+
+	return r.readBytes(file.DataOffset, int(file.CompressedSize))
+}
+
+// Helper functions
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

pkg/rar/types.go

@@ -0,0 +1,37 @@
+package rar
+
+import (
+	"net/http"
+	"time"
+)
+
+// File represents a file entry in a RAR archive
+type File struct {
+	Path           string
+	Size           int64
+	CompressedSize int64
+	Method         byte
+	CRC            uint32
+	IsDirectory    bool
+	DataOffset     int64
+	NextOffset     int64
+}
+
+// Access point for a RAR archive served through HTTP
+type HttpFile struct {
+	URL        string
+	Position   int64
+	Client     *http.Client
+	FileSize   int64
+	MaxRetries int
+	RetryDelay time.Duration
+}
+
+// Reader reads RAR3 format archives
+type Reader struct {
+	File         *HttpFile
+	ChunkSize    int
+	Marker       int64
+	HeaderEndPos int64 // Position after the archive header
+	Files        []*File
+}

pkg/repair/clean.go

@@ -1,159 +0,0 @@
-package repair
-
-//func (r *Repair) clean(job *Job) error {
-//	// Create a new error group
-//	g, ctx := errgroup.WithContext(context.Background())
-//
-//	uniqueItems := make(map[string]string)
-//	mu := sync.Mutex{}
-//
-//	// Limit concurrent goroutines
-//	g.SetLimit(10)
-//
-//	for _, a := range job.Arrs {
-//		a := a // Capture range variable
-//		g.Go(func() error {
-//			// Check if context was canceled
-//			select {
-//			case <-ctx.Done():
-//				return ctx.Err()
-//			default:
-//			}
-//
-//			items, err := r.cleanArr(job, a, "")
-//			if err != nil {
-//				r.logger.Error().Err(err).Msgf("Error cleaning %s", a)
-//				return err
-//			}
-//
-//			// Safely append the found items to the shared slice
-//			if len(items) > 0 {
-//				mu.Lock()
-//				for k, v := range items {
-//					uniqueItems[k] = v
-//				}
-//				mu.Unlock()
-//			}
-//
-//			return nil
-//		})
-//	}
-//
-//	if err := g.Wait(); err != nil {
-//		return err
-//	}
-//
-//	if len(uniqueItems) == 0 {
-//		job.CompletedAt = time.Now()
-//		job.Status = JobCompleted
-//
-//		go func() {
-//			if err := request.SendDiscordMessage("repair_clean_complete", "success", job.discordContext()); err != nil {
-//				r.logger.Error().Msgf("Error sending discord message: %v", err)
-//			}
-//		}()
-//
-//		return nil
-//	}
-//
-//	cache := r.deb.Caches["realdebrid"]
-//	if cache == nil {
-//		return fmt.Errorf("cache not found")
-//	}
-//	torrents := cache.GetTorrents()
-//
-//	dangling := make([]string, 0)
-//	for _, t := range torrents {
-//		if _, ok := uniqueItems[t.Name]; !ok {
-//			dangling = append(dangling, t.Id)
-//		}
-//	}
-//
-//	r.logger.Info().Msgf("Found %d delapitated items", len(dangling))
-//
-//	if len(dangling) == 0 {
-//		job.CompletedAt = time.Now()
-//		job.Status = JobCompleted
-//		return nil
-//	}
-//
-//	client := r.deb.Clients["realdebrid"]
-//	if client == nil {
-//		return fmt.Errorf("client not found")
-//	}
-//	for _, id := range dangling {
-//		err := client.DeleteTorrent(id)
-//		if err != nil {
-//			return err
-//		}
-//	}
-//
-//	return nil
-//}
-//
-//func (r *Repair) cleanArr(j *Job, _arr string, tmdbId string) (map[string]string, error) {
-//	uniqueItems := make(map[string]string)
-//	a := r.arrs.Get(_arr)
-//
-//	r.logger.Info().Msgf("Starting repair for %s", a.Name)
-//	media, err := a.GetMedia(tmdbId)
-//	if err != nil {
-//		r.logger.Info().Msgf("Failed to get %s media: %v", a.Name, err)
-//		return uniqueItems, err
-//	}
-//
-//	// Create a new error group
-//	g, ctx := errgroup.WithContext(context.Background())
-//
-//	mu := sync.Mutex{}
-//
-//	// Limit concurrent goroutines
-//	g.SetLimit(runtime.NumCPU() * 4)
-//
-//	for _, m := range media {
-//		m := m // Create a new variable scoped to the loop iteration
-//		g.Go(func() error {
-//			// Check if context was canceled
-//			select {
-//			case <-ctx.Done():
-//				return ctx.Err()
-//			default:
-//			}
-//
-//			u := r.getUniquePaths(m)
-//			for k, v := range u {
-//				mu.Lock()
-//				uniqueItems[k] = v
-//				mu.Unlock()
-//			}
-//			return nil
-//		})
-//	}
-//
-//	if err := g.Wait(); err != nil {
-//		return uniqueItems, err
-//	}
-//
-//	r.logger.Info().Msgf("Repair completed for %s. %d unique items", a.Name, len(uniqueItems))
-//	return uniqueItems, nil
-//}
-
-//func (r *Repair) getUniquePaths(media arr.Content) map[string]string {
-//	// Use zurg setup to check file availability with zurg
-//	// This reduces bandwidth usage significantly
-//
-//	uniqueParents := make(map[string]string)
-//	files := media.Files
-//	for _, file := range files {
-//		target := getSymlinkTarget(file.Path)
-//		if target != "" {
-//			file.IsSymlink = true
-//			dir, f := filepath.Split(target)
-//			parent := filepath.Base(filepath.Clean(dir))
-//			// Set target path folder/file.mkv
-//			file.TargetPath = f
-//			uniqueParents[parent] = target
-//		}
-//	}
-//	return uniqueParents
-//}

pkg/repair/misc.go

@@ -3,75 +3,12 @@ package repair
 import (
 	"fmt"
 	"github.com/sirrobot01/decypharr/pkg/arr"
+	"github.com/sirrobot01/decypharr/pkg/debrid/store"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
 	"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 {
@@ -147,3 +84,92 @@ func collectFiles(media arr.Content) map[string][]arr.ContentFile {
 	}
 	return uniqueParents
 }
+
+func (r *Repair) checkTorrentFiles(torrentPath string, files []arr.ContentFile, clients map[string]types.Client, caches map[string]*store.Cache) []arr.ContentFile {
+	brokenFiles := make([]arr.ContentFile, 0)
+
+	r.logger.Debug().Msgf("Checking %s", torrentPath)
+
+	// Get the debrid client
+	dir := filepath.Dir(torrentPath)
+	debridName := r.findDebridForPath(dir, clients)
+	if debridName == "" {
+		r.logger.Debug().Msgf("No debrid found for %s. Skipping", torrentPath)
+		return files // Return all files as broken if no debrid found
+	}
+
+	cache, ok := caches[debridName]
+	if !ok {
+		r.logger.Debug().Msgf("No cache found for %s. Skipping", debridName)
+		return files // Return all files as broken if no cache found
+	}
+	tor, ok := r.torrentsMap.Load(debridName)
+	if !ok {
+		r.logger.Debug().Msgf("Could not find torrents for %s. Skipping", debridName)
+	}
+
+	torrentsMap := tor.(map[string]store.CachedTorrent)
+
+	// Check if torrent exists
+	torrentName := filepath.Clean(filepath.Base(torrentPath))
+	torrent, ok := torrentsMap[torrentName]
+	if !ok {
+		r.logger.Debug().Msgf("No torrent found for %s. Skipping", torrentName)
+		return files // Return all files as broken if torrent not found
+	}
+
+	// Batch check files
+	filePaths := make([]string, len(files))
+	for i, file := range files {
+		filePaths[i] = file.TargetPath
+	}
+
+	brokenFilePaths := cache.GetBrokenFiles(&torrent, filePaths)
+	if len(brokenFilePaths) > 0 {
+		r.logger.Debug().Msgf("%d broken files found in %s", len(brokenFilePaths), torrentName)
+
+		// Create a set for O(1) lookup
+		brokenSet := make(map[string]bool, len(brokenFilePaths))
+		for _, brokenPath := range brokenFilePaths {
+			brokenSet[brokenPath] = true
+		}
+
+		// Filter broken files
+		for _, contentFile := range files {
+			if brokenSet[contentFile.TargetPath] {
+				brokenFiles = append(brokenFiles, contentFile)
+			}
+		}
+	}
+
+	return brokenFiles
+}
+
+func (r *Repair) findDebridForPath(dir string, clients map[string]types.Client) string {
+	// Check cache first
+	if debridName, exists := r.debridPathCache.Load(dir); exists {
+		return debridName.(string)
+	}
+
+	// Find debrid client
+	for _, client := range clients {
+		mountPath := client.GetMountPath()
+		if mountPath == "" {
+			continue
+		}
+
+		if filepath.Clean(mountPath) == filepath.Clean(dir) {
+			debridName := client.Name()
+
+			// Cache the result
+			r.debridPathCache.Store(dir, debridName)
+
+			return debridName
+		}
+	}
+
+	// Cache empty result to avoid repeated lookups
+	r.debridPathCache.Store(dir, "")
+
+	return ""
+}

pkg/repair/repair.go

@@ -2,15 +2,18 @@ package repair
 
 import (
 	"context"
+	"encoding/json"
+	"errors"
 	"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"
+	"github.com/sirrobot01/decypharr/pkg/debrid"
 	"golang.org/x/sync/errgroup"
 	"net"
 	"net/http"
@@ -27,9 +30,8 @@ import (
 type Repair struct {
 	Jobs        map[string]*Job
 	arrs        *arr.Storage
-	deb         *debrid.Engine
-	duration    time.Duration
-	runOnStart  bool
+	deb         *debrid.Storage
+	interval    string
 	ZurgURL     string
 	IsZurg      bool
 	useWebdav   bool
@@ -37,15 +39,44 @@ type Repair struct {
 	logger      zerolog.Logger
 	filename    string
 	workers     int
-	ctx         context.Context
+	scheduler   gocron.Scheduler
+
+	debridPathCache sync.Map // debridPath:debridName cache.Emptied after each run
+	torrentsMap     sync.Map //debridName: map[string]*store.CacheTorrent. Emptied after each run
+	ctx             context.Context
 }
 
-func New(arrs *arr.Storage, engine *debrid.Engine) *Repair {
+type JobStatus string
+
+const (
+	JobStarted    JobStatus = "started"
+	JobPending    JobStatus = "pending"
+	JobFailed     JobStatus = "failed"
+	JobCompleted  JobStatus = "completed"
+	JobProcessing JobStatus = "processing"
+	JobCancelled  JobStatus = "cancelled"
+)
+
+type Job struct {
+	ID          string                       `json:"id"`
+	Arrs        []string                     `json:"arrs"`
+	MediaIDs    []string                     `json:"media_ids"`
+	StartedAt   time.Time                    `json:"created_at"`
+	BrokenItems map[string][]arr.ContentFile `json:"broken_items"`
+	Status      JobStatus                    `json:"status"`
+	CompletedAt time.Time                    `json:"finished_at"`
+	FailedAt    time.Time                    `json:"failed_at"`
+	AutoProcess bool                         `json:"auto_process"`
+	Recurrent   bool                         `json:"recurrent"`
+
+	Error string `json:"error"`
+
+	cancelFunc context.CancelFunc
+	ctx        context.Context
+}
+
+func New(arrs *arr.Storage, engine *debrid.Storage) *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
@@ -53,8 +84,7 @@ func New(arrs *arr.Storage, engine *debrid.Engine) *Repair {
 	r := &Repair{
 		arrs:        arrs,
 		logger:      logger.New("repair"),
-		duration:    duration,
-		runOnStart:  cfg.Repair.RunOnStart,
+		interval:    cfg.Repair.Interval,
 		ZurgURL:     cfg.Repair.ZurgURL,
 		useWebdav:   cfg.Repair.UseWebDav,
 		autoProcess: cfg.Repair.AutoProcess,
@@ -72,67 +102,49 @@ func New(arrs *arr.Storage, engine *debrid.Engine) *Repair {
 	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")
-			}
-		}()
-	}
+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")
+		}
 
-	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"))
+		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)
+
 }
 
-type JobStatus string
+func (r *Repair) Start(ctx context.Context) error {
 
-const (
-	JobStarted    JobStatus = "started"
-	JobPending    JobStatus = "pending"
-	JobFailed     JobStatus = "failed"
-	JobCompleted  JobStatus = "completed"
-	JobProcessing JobStatus = "processing"
-)
+	r.scheduler, _ = gocron.NewScheduler(gocron.WithLocation(time.Local))
 
-type Job struct {
-	ID          string                       `json:"id"`
-	Arrs        []string                     `json:"arrs"`
-	MediaIDs    []string                     `json:"media_ids"`
-	StartedAt   time.Time                    `json:"created_at"`
-	BrokenItems map[string][]arr.ContentFile `json:"broken_items"`
-	Status      JobStatus                    `json:"status"`
-	CompletedAt time.Time                    `json:"finished_at"`
-	FailedAt    time.Time                    `json:"failed_at"`
-	AutoProcess bool                         `json:"auto_process"`
-	Recurrent   bool                         `json:"recurrent"`
+	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)
+		}
+	}
 
-	Error string `json:"error"`
+	<-ctx.Done()
+
+	r.logger.Info().Msg("Stopping repair scheduler")
+	r.Reset()
+
+	return nil
 }
 
 func (j *Job) discordContext() string {
@@ -202,10 +214,32 @@ func (r *Repair) newJob(arrsNames []string, mediaIDs []string) *Job {
 	}
 }
 
+// initRun initializes the repair run, setting up necessary configurations, checks and caches
+func (r *Repair) initRun(ctx context.Context) {
+	if r.useWebdav {
+		// Webdav use is enabled, initialize debrid torrent caches
+		caches := r.deb.Caches()
+		if len(caches) == 0 {
+			return
+		}
+		for name, cache := range caches {
+			r.torrentsMap.Store(name, cache.GetTorrentsName())
+		}
+	}
+}
+
+// // onComplete is called when the repair job is completed
+func (r *Repair) onComplete() {
+	// Set the cache maps to nil
+	r.torrentsMap = sync.Map{} // Clear the torrent map
+	r.debridPathCache = sync.Map{}
+}
+
 func (r *Repair) preRunChecks() error {
 
 	if r.useWebdav {
-		if len(r.deb.Caches) == 0 {
+		caches := r.deb.Caches()
+		if len(caches) == 0 {
 			return fmt.Errorf("no caches found")
 		}
 		return nil
@@ -217,7 +251,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 {
@@ -239,31 +273,75 @@ func (r *Repair) AddJob(arrsNames []string, mediaIDs []string, autoProcess, recu
 	job.AutoProcess = autoProcess
 	job.Recurrent = recurrent
 	r.reset(job)
+
+	job.ctx, job.cancelFunc = context.WithCancel(r.ctx)
 	r.Jobs[key] = job
 	go r.saveToFile()
 	go func() {
 		if err := r.repair(job); err != nil {
 			r.logger.Error().Err(err).Msg("Error running repair")
-			r.logger.Error().Err(err).Msg("Error running repair")
-			job.FailedAt = time.Now()
-			job.Error = err.Error()
-			job.Status = JobFailed
-			job.CompletedAt = time.Now()
+			if !errors.Is(job.ctx.Err(), context.Canceled) {
+				job.FailedAt = time.Now()
+				job.Error = err.Error()
+				job.Status = JobFailed
+				job.CompletedAt = time.Now()
+			} else {
+				job.FailedAt = time.Now()
+				job.Error = err.Error()
+				job.Status = JobFailed
+				job.CompletedAt = time.Now()
+			}
 		}
+		r.onComplete() // Clear caches and maps after job completion
 	}()
 	return nil
 }
 
+func (r *Repair) StopJob(id string) error {
+	job := r.GetJob(id)
+	if job == nil {
+		return fmt.Errorf("job %s not found", id)
+	}
+
+	// Check if job can be stopped
+	if job.Status != JobStarted && job.Status != JobProcessing {
+		return fmt.Errorf("job %s cannot be stopped (status: %s)", id, job.Status)
+	}
+
+	// Cancel the job
+	if job.cancelFunc != nil {
+		job.cancelFunc()
+		r.logger.Info().Msgf("Job %s cancellation requested", id)
+		go func() {
+			if job.Status == JobStarted || job.Status == JobProcessing {
+				job.Status = JobCancelled
+				job.BrokenItems = nil
+				job.ctx = nil // Clear context to prevent further processing
+				job.CompletedAt = time.Now()
+				job.Error = "Job was cancelled by user"
+				r.saveToFile()
+			}
+		}()
+
+		return nil
+	}
+
+	return fmt.Errorf("job %s cannot be cancelled", id)
+}
+
 func (r *Repair) repair(job *Job) error {
 	defer r.saveToFile()
 	if err := r.preRunChecks(); err != nil {
 		return err
 	}
 
+	// Initialize the run
+	r.initRun(job.ctx)
+
 	// Use a mutex to protect concurrent access to brokenItems
 	var mu sync.Mutex
 	brokenItems := map[string][]arr.ContentFile{}
-	g, ctx := errgroup.WithContext(r.ctx)
+	g, ctx := errgroup.WithContext(job.ctx)
 
 	for _, a := range job.Arrs {
 		a := a // Capture range variable
@@ -306,6 +384,14 @@ func (r *Repair) repair(job *Job) error {
 
 	// Wait for all goroutines to complete and check for errors
 	if err := g.Wait(); err != nil {
+		// Check if j0b was canceled
+		if errors.Is(ctx.Err(), context.Canceled) {
+			job.Status = JobCancelled
+			job.CompletedAt = time.Now()
+			job.Error = "Job was cancelled"
+			return fmt.Errorf("job cancelled")
+		}
+
 		job.FailedAt = time.Now()
 		job.Error = err.Error()
 		job.Status = JobFailed
@@ -352,7 +438,7 @@ func (r *Repair) repair(job *Job) error {
 	return nil
 }
 
-func (r *Repair) repairArr(j *Job, _arr string, tmdbId string) ([]arr.ContentFile, error) {
+func (r *Repair) repairArr(job *Job, _arr string, tmdbId string) ([]arr.ContentFile, error) {
 	brokenItems := make([]arr.ContentFile, 0)
 	a := r.arrs.Get(_arr)
 
@@ -369,9 +455,9 @@ func (r *Repair) repairArr(j *Job, _arr string, tmdbId string) ([]arr.ContentFil
 		return brokenItems, nil
 	}
 	// Check first media to confirm mounts are accessible
-	if !r.isMediaAccessible(media[0]) {
-		r.logger.Info().Msgf("Skipping repair. Parent directory not accessible for. Check your mounts")
-		return brokenItems, nil
+	if err := r.checkMountUp(media); err != nil {
+		r.logger.Error().Err(err).Msgf("Mount check failed for %s", a.Name)
+		return brokenItems, fmt.Errorf("mount check failed: %w", err)
 	}
 
 	// Mutex for brokenItems
@@ -385,14 +471,14 @@ func (r *Repair) repairArr(j *Job, _arr string, tmdbId string) ([]arr.ContentFil
 			defer wg.Done()
 			for m := range workerChan {
 				select {
-				case <-r.ctx.Done():
+				case <-job.ctx.Done():
 					return
 				default:
 				}
-				items := r.getBrokenFiles(m)
+				items := r.getBrokenFiles(job, m)
 				if items != nil {
 					r.logger.Debug().Msgf("Found %d broken files for %s", len(items), m.Title)
-					if j.AutoProcess {
+					if job.AutoProcess {
 						r.logger.Info().Msgf("Auto processing %d broken items for %s", len(items), m.Title)
 
 						// Delete broken items
@@ -414,16 +500,17 @@ func (r *Repair) repairArr(j *Job, _arr string, tmdbId string) ([]arr.ContentFil
 		}()
 	}
 
-	for _, m := range media {
-		select {
-		case <-r.ctx.Done():
-			break
-		default:
-			workerChan <- m
+	go func() {
+		defer close(workerChan)
+		for _, m := range media {
+			select {
+			case <-job.ctx.Done():
+				return
+			case workerChan <- m:
+			}
 		}
-	}
+	}()
 
-	close(workerChan)
 	wg.Wait()
 	if len(brokenItems) == 0 {
 		r.logger.Info().Msgf("No broken items found for %s", a.Name)
@@ -434,58 +521,60 @@ func (r *Repair) repairArr(j *Job, _arr string, tmdbId string) ([]arr.ContentFil
 	return brokenItems, nil
 }
 
-func (r *Repair) isMediaAccessible(m arr.Content) bool {
-	files := m.Files
-	if len(files) == 0 {
-		return false
-	}
-	firstFile := files[0]
-	r.logger.Debug().Msgf("Checking parent directory for %s", firstFile.Path)
-	//if _, err := os.Stat(firstFile.Path); os.IsNotExist(err) {
-	//	r.logger.Debug().Msgf("Parent directory not accessible for %s", firstFile.Path)
-	//	return false
-	//}
-	// Check symlink parent directory
-	symlinkPath := getSymlinkTarget(firstFile.Path)
-
-	r.logger.Debug().Msgf("Checking symlink parent directory for %s", symlinkPath)
-
-	if symlinkPath != "" {
-		parentSymlink := filepath.Dir(filepath.Dir(symlinkPath)) // /mnt/zurg/torrents/movie/movie.mkv -> /mnt/zurg/torrents
-		if _, err := os.Stat(parentSymlink); os.IsNotExist(err) {
-			return false
+// checkMountUp checks if the mounts are accessible
+func (r *Repair) checkMountUp(media []arr.Content) error {
+	firstMedia := media[0]
+	for _, m := range media {
+		if len(m.Files) > 0 {
+			firstMedia = m
+			break
 		}
 	}
-	return true
+	files := firstMedia.Files
+	if len(files) == 0 {
+		return fmt.Errorf("no files found in media %s", firstMedia.Title)
+	}
+	firstFile := files[0]
+	symlinkPath := getSymlinkTarget(firstFile.Path)
+
+	if symlinkPath == "" {
+		return fmt.Errorf("no symlink target found for %s", firstFile.Path)
+	}
+	r.logger.Debug().Msgf("Checking symlink parent directory for %s", symlinkPath)
+
+	parentSymlink := filepath.Dir(filepath.Dir(symlinkPath)) // /mnt/zurg/torrents/movie/movie.mkv -> /mnt/zurg/torrents
+	if _, err := os.Stat(parentSymlink); os.IsNotExist(err) {
+		return fmt.Errorf("parent directory %s not accessible for %s", parentSymlink, firstFile.Path)
+	}
+	return nil
 }
 
-func (r *Repair) getBrokenFiles(media arr.Content) []arr.ContentFile {
+func (r *Repair) getBrokenFiles(job *Job, media arr.Content) []arr.ContentFile {
 
 	if r.useWebdav {
-		return r.getWebdavBrokenFiles(media)
+		return r.getWebdavBrokenFiles(job, media)
 	} else if r.IsZurg {
-		return r.getZurgBrokenFiles(media)
+		return r.getZurgBrokenFiles(job, media)
 	} else {
-		return r.getFileBrokenFiles(media)
+		return r.getFileBrokenFiles(job, media)
 	}
 }
 
-func (r *Repair) getFileBrokenFiles(media arr.Content) []arr.ContentFile {
+func (r *Repair) getFileBrokenFiles(job *Job, media arr.Content) []arr.ContentFile {
 	// This checks symlink target, try to get read a tiny bit of the file
 
 	brokenFiles := make([]arr.ContentFile, 0)
 
 	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 {
@@ -496,7 +585,7 @@ func (r *Repair) getFileBrokenFiles(media arr.Content) []arr.ContentFile {
 	return brokenFiles
 }
 
-func (r *Repair) getZurgBrokenFiles(media arr.Content) []arr.ContentFile {
+func (r *Repair) getZurgBrokenFiles(job *Job, media arr.Content) []arr.ContentFile {
 	// Use zurg setup to check file availability with zurg
 	// This reduces bandwidth usage significantly
 
@@ -511,41 +600,49 @@ 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
-		}
+		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)
+				if err := resp.Body.Close(); err != nil {
+					return nil
+				}
+				brokenFiles = append(brokenFiles, file)
+				continue
+			}
+			downloadUrl := resp.Request.URL.String()
 
-		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, 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 err := resp.Body.Close(); err != nil {
+				return nil
+			}
+			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 {
@@ -556,16 +653,16 @@ func (r *Repair) getZurgBrokenFiles(media arr.Content) []arr.ContentFile {
 	return brokenFiles
 }
 
-func (r *Repair) getWebdavBrokenFiles(media arr.Content) []arr.ContentFile {
+func (r *Repair) getWebdavBrokenFiles(job *Job, media arr.Content) []arr.ContentFile {
 	// Use internal webdav setup to check file availability
 
-	caches := r.deb.Caches
+	caches := r.deb.Caches()
 	if len(caches) == 0 {
 		r.logger.Info().Msg("No caches found. Can't use webdav")
 		return nil
 	}
 
-	clients := r.deb.Clients
+	clients := r.deb.Clients()
 	if len(clients) == 0 {
 		r.logger.Info().Msg("No clients found. Can't use webdav")
 		return nil
@@ -573,54 +670,18 @@ 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
-		dir := filepath.Dir(torrentPath)
-		debridName := ""
-		for _, client := range clients {
-			mountPath := client.GetMountPath()
-			if mountPath == "" {
-				continue
-			}
-
-			if filepath.Clean(mountPath) == filepath.Clean(dir) {
-				debridName = client.GetName()
-				break
-			}
+	for torrentPath, files := range uniqueParents {
+		select {
+		case <-job.ctx.Done():
+			return brokenFiles
+		default:
 		}
-		if debridName == "" {
-			r.logger.Debug().Msgf("No debrid found for %s. Skipping", torrentPath)
-			continue
+		brokenFilesForTorrent := r.checkTorrentFiles(torrentPath, files, clients, caches)
+		if len(brokenFilesForTorrent) > 0 {
+			brokenFiles = append(brokenFiles, brokenFilesForTorrent...)
 		}
-		cache, ok := caches[debridName]
-		if !ok {
-			r.logger.Debug().Msgf("No cache found for %s. Skipping", debridName)
-			continue
-		}
-		// Check if torrent exists
-		torrentName := filepath.Clean(filepath.Base(torrentPath))
-		torrent := cache.GetTorrentByName(torrentName)
-		if torrent == nil {
-			r.logger.Debug().Msgf("No torrent found for %s. Skipping", torrentName)
-			continue
-		}
-		files := make([]string, 0)
-		for _, file := range f {
-			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
-		}
-
 	}
 	if len(brokenFiles) == 0 {
-		r.logger.Debug().Msgf("No broken files found for %s", media.Title)
 		return nil
 	}
 	r.logger.Debug().Msgf("%d broken files found for %s", len(brokenFiles), media.Title)
@@ -653,7 +714,6 @@ func (r *Repair) ProcessJob(id string) error {
 	if job == nil {
 		return fmt.Errorf("job %s not found", id)
 	}
-	// All validation checks remain the same
 	if job.Status != JobPending {
 		return fmt.Errorf("job %s not pending", id)
 	}
@@ -675,7 +735,11 @@ func (r *Repair) ProcessJob(id string) error {
 		return nil
 	}
 
-	g, ctx := errgroup.WithContext(r.ctx)
+	if job.ctx == nil || job.ctx.Err() != nil {
+		job.ctx, job.cancelFunc = context.WithCancel(r.ctx)
+	}
+
+	g, ctx := errgroup.WithContext(job.ctx)
 	g.SetLimit(r.workers)
 
 	for arrName, items := range brokenItems {
@@ -736,7 +800,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 +814,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 +842,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/debug.go

@@ -0,0 +1,122 @@
+package server
+
+import (
+	"fmt"
+	"github.com/go-chi/chi/v5"
+	"github.com/sirrobot01/decypharr/internal/request"
+	debridTypes "github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"github.com/sirrobot01/decypharr/pkg/store"
+	"net/http"
+	"runtime"
+)
+
+func (s *Server) handleIngests(w http.ResponseWriter, r *http.Request) {
+	ingests := make([]debridTypes.IngestData, 0)
+	_store := store.Get()
+	debrids := _store.Debrid()
+	if debrids == nil {
+		http.Error(w, "Debrid service is not enabled", http.StatusInternalServerError)
+		return
+	}
+	for _, cache := range debrids.Caches() {
+		if cache == nil {
+			s.logger.Error().Msg("Debrid cache is nil, skipping")
+			continue
+		}
+		data, err := cache.GetIngests()
+		if err != nil {
+			s.logger.Error().Err(err).Msg("Failed to get ingests from debrid cache")
+			http.Error(w, "Failed to get ingests: "+err.Error(), http.StatusInternalServerError)
+			return
+		}
+		ingests = append(ingests, data...)
+	}
+
+	request.JSONResponse(w, ingests, 200)
+}
+
+func (s *Server) handleIngestsByDebrid(w http.ResponseWriter, r *http.Request) {
+	debridName := chi.URLParam(r, "debrid")
+	if debridName == "" {
+		http.Error(w, "Debrid name is required", http.StatusBadRequest)
+		return
+	}
+
+	_store := store.Get()
+	debrids := _store.Debrid()
+
+	if debrids == nil {
+		http.Error(w, "Debrid service is not enabled", http.StatusInternalServerError)
+		return
+	}
+
+	caches := debrids.Caches()
+
+	cache, exists := caches[debridName]
+	if !exists {
+		http.Error(w, "Debrid cache not found: "+debridName, http.StatusNotFound)
+		return
+	}
+
+	data, err := cache.GetIngests()
+	if err != nil {
+		s.logger.Error().Err(err).Msg("Failed to get ingests from debrid cache")
+		http.Error(w, "Failed to get ingests: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	request.JSONResponse(w, data, 200)
+}
+
+func (s *Server) handleStats(w http.ResponseWriter, r *http.Request) {
+	var memStats runtime.MemStats
+	runtime.ReadMemStats(&memStats)
+
+	stats := map[string]any{
+		// Memory stats
+		"heap_alloc_mb":  fmt.Sprintf("%.2fMB", float64(memStats.HeapAlloc)/1024/1024),
+		"total_alloc_mb": fmt.Sprintf("%.2fMB", float64(memStats.TotalAlloc)/1024/1024),
+		"memory_used":    fmt.Sprintf("%.2fMB", float64(memStats.Sys)/1024/1024),
+
+		// GC stats
+		"gc_cycles": memStats.NumGC,
+		// Goroutine stats
+		"goroutines": runtime.NumGoroutine(),
+
+		// System info
+		"num_cpu": runtime.NumCPU(),
+
+		// OS info
+		"os":         runtime.GOOS,
+		"arch":       runtime.GOARCH,
+		"go_version": runtime.Version(),
+	}
+
+	debrids := store.Get().Debrid()
+	if debrids == nil {
+		request.JSONResponse(w, stats, http.StatusOK)
+		return
+	}
+	clients := debrids.Clients()
+	caches := debrids.Caches()
+	profiles := make([]*debridTypes.Profile, 0)
+	for debridName, client := range clients {
+		profile, err := client.GetProfile()
+		profile.Name = debridName
+		if err != nil {
+			s.logger.Error().Err(err).Msg("Failed to get debrid profile")
+			continue
+		}
+		cache, ok := caches[debridName]
+		if ok {
+			// Get torrent data
+			profile.LibrarySize = cache.TotalTorrents()
+			profile.BadTorrents = len(cache.GetListing("__bad__"))
+			profile.ActiveLinks = cache.GetTotalActiveDownloadLinks()
+
+		}
+		profiles = append(profiles, profile)
+	}
+	stats["debrids"] = profiles
+	request.JSONResponse(w, stats, http.StatusOK)
+}

pkg/server/server.go

@@ -6,16 +6,13 @@ 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"
 	"io"
 	"net/http"
+	"net/url"
 	"os"
-	"os/signal"
-	"runtime"
-	"syscall"
 )
 
 type Server struct {
@@ -23,41 +20,57 @@ 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)
+
+		//debugs
+		r.Route("/debug", func(r chi.Router) {
+			r.Get("/stats", s.handleStats)
+			r.Get("/ingests", s.handleIngests)
+			r.Get("/ingests/{debrid}", s.handleIngestsByDebrid)
+		})
+
+		//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()
+			s.logger.Error().Err(err).Msgf("Error starting server")
 		}
 	}()
 
@@ -66,14 +79,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 +91,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)
 
@@ -98,36 +103,5 @@ func (s *Server) getLogs(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Expires", "0")
 
 	// Stream the file
-	_, err = io.Copy(w, file)
-	if err != nil {
-		s.logger.Debug().Err(err).Msg("Error streaming log file")
-		http.Error(w, "Error streaming log file", http.StatusInternalServerError)
-		return
-	}
-}
-
-func (s *Server) getStats(w http.ResponseWriter, r *http.Request) {
-	var memStats runtime.MemStats
-	runtime.ReadMemStats(&memStats)
-
-	stats := map[string]interface{}{
-		// 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),
-
-		// GC stats
-		"gc_cycles": memStats.NumGC,
-		// Goroutine stats
-		"goroutines": runtime.NumGoroutine(),
-
-		// 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")
-	}
+	_, _ = io.Copy(w, file)
 }

pkg/server/webhook.go

@@ -2,8 +2,8 @@ package server
 
 import (
 	"cmp"
-	"github.com/goccy/go-json"
-	"github.com/sirrobot01/decypharr/pkg/service"
+	"encoding/json"
+	"github.com/sirrobot01/decypharr/pkg/store"
 	"net/http"
 )
 
@@ -38,8 +38,7 @@ func (s *Server) handleTautulli(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Invalid ID", http.StatusBadRequest)
 		return
 	}
-	svc := service.GetService()
-	repair := svc.Repair
+	repair := store.Get().Repair()
 
 	mediaId := cmp.Or(payload.TmdbID, payload.TvdbID)
 

pkg/service/service.go

@@ -1,55 +0,0 @@
-package service
-
-import (
-	"github.com/sirrobot01/decypharr/pkg/arr"
-	"github.com/sirrobot01/decypharr/pkg/debrid/debrid"
-	"github.com/sirrobot01/decypharr/pkg/repair"
-	"sync"
-)
-
-type Service struct {
-	Repair *repair.Repair
-	Arr    *arr.Storage
-	Debrid *debrid.Engine
-}
-
-var (
-	instance *Service
-	once     sync.Once
-)
-
-func New() *Service {
-	once.Do(func() {
-		arrs := arr.NewStorage()
-		deb := debrid.NewEngine()
-		instance = &Service{
-			Repair: repair.New(arrs, deb),
-			Arr:    arrs,
-			Debrid: deb,
-		}
-	})
-	return instance
-}
-
-// GetService returns the singleton instance
-func GetService() *Service {
-	if instance == nil {
-		instance = New()
-	}
-	return instance
-}
-
-func Update() *Service {
-	arrs := arr.NewStorage()
-	deb := debrid.NewEngine()
-	instance = &Service{
-		Repair: repair.New(arrs, deb),
-		Arr:    arrs,
-		Debrid: deb,
-	}
-	return instance
-}
-
-func GetDebrid() *debrid.Engine {
-	return GetService().Debrid
-}

pkg/store/downloader.go

@@ -0,0 +1,317 @@
+package store
+
+import (
+	"fmt"
+	"github.com/sirrobot01/decypharr/pkg/debrid/types"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+
+	"github.com/cavaliergopher/grab/v3"
+	"github.com/sirrobot01/decypharr/internal/utils"
+)
+
+func grabber(client *grab.Client, url, filename string, byterange *[2]int64, progressCallback func(int64, int64)) error {
+	req, err := grab.NewRequest(filename, url)
+	if err != nil {
+		return err
+	}
+
+	// Set byte range if specified
+	if byterange != nil {
+		byterangeStr := fmt.Sprintf("%d-%d", byterange[0], byterange[1])
+		req.HTTPRequest.Header.Set("Range", "bytes="+byterangeStr)
+	}
+
+	resp := client.Do(req)
+
+	t := time.NewTicker(time.Second * 2)
+	defer t.Stop()
+
+	var lastReported int64
+Loop:
+	for {
+		select {
+		case <-t.C:
+			current := resp.BytesComplete()
+			speed := int64(resp.BytesPerSecond())
+			if current != lastReported {
+				if progressCallback != nil {
+					progressCallback(current-lastReported, speed)
+				}
+				lastReported = current
+			}
+		case <-resp.Done:
+			break Loop
+		}
+	}
+
+	// Report final bytes
+	if progressCallback != nil {
+		progressCallback(resp.BytesComplete()-lastReported, 0)
+	}
+
+	return resp.Err()
+}
+
+func (s *Store) processDownload(torrent *Torrent, debridTorrent *types.Torrent) (string, error) {
+	s.logger.Info().Msgf("Downloading %d files...", len(debridTorrent.Files))
+	torrentPath := filepath.Join(torrent.SavePath, utils.RemoveExtension(debridTorrent.OriginalFilename))
+	torrentPath = utils.RemoveInvalidChars(torrentPath)
+	err := os.MkdirAll(torrentPath, os.ModePerm)
+	if err != nil {
+		// add the previous error to the error and return
+		return "", fmt.Errorf("failed to create directory: %s: %v", torrentPath, err)
+	}
+	s.downloadFiles(torrent, debridTorrent, torrentPath)
+	return torrentPath, nil
+}
+
+func (s *Store) downloadFiles(torrent *Torrent, debridTorrent *types.Torrent, parent string) {
+	var wg sync.WaitGroup
+
+	totalSize := int64(0)
+	for _, file := range debridTorrent.GetFiles() {
+		totalSize += file.Size
+	}
+	debridTorrent.Lock()
+	debridTorrent.SizeDownloaded = 0 // Reset downloaded bytes
+	debridTorrent.Progress = 0       // Reset progress
+	debridTorrent.Unlock()
+	progressCallback := func(downloaded int64, speed int64) {
+		debridTorrent.Lock()
+		defer debridTorrent.Unlock()
+		torrent.Lock()
+		defer torrent.Unlock()
+
+		// Update total downloaded bytes
+		debridTorrent.SizeDownloaded += downloaded
+		debridTorrent.Speed = speed
+
+		// Calculate overall progress
+		if totalSize > 0 {
+			debridTorrent.Progress = float64(debridTorrent.SizeDownloaded) / float64(totalSize) * 100
+		}
+		s.partialTorrentUpdate(torrent, debridTorrent)
+	}
+	client := &grab.Client{
+		UserAgent: "Decypharr[QBitTorrent]",
+		HTTPClient: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		},
+	}
+	errChan := make(chan error, len(debridTorrent.Files))
+	for _, file := range debridTorrent.GetFiles() {
+		if file.DownloadLink == nil {
+			s.logger.Info().Msgf("No download link found for %s", file.Name)
+			continue
+		}
+		wg.Add(1)
+		s.downloadSemaphore <- struct{}{}
+		go func(file types.File) {
+			defer wg.Done()
+			defer func() { <-s.downloadSemaphore }()
+			filename := file.Name
+
+			err := grabber(
+				client,
+				file.DownloadLink.DownloadLink,
+				filepath.Join(parent, filename),
+				file.ByteRange,
+				progressCallback,
+			)
+
+			if err != nil {
+				s.logger.Error().Msgf("Failed to download %s: %v", filename, err)
+				errChan <- err
+			} else {
+				s.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 {
+		s.logger.Error().Msgf("Errors occurred during download: %v", errors)
+		return
+	}
+	s.logger.Info().Msgf("Downloaded all files for %s", debridTorrent.Name)
+}
+
+func (s *Store) processSymlink(torrent *Torrent, debridTorrent *types.Torrent) (string, error) {
+	files := debridTorrent.Files
+	if len(files) == 0 {
+		return "", fmt.Errorf("no video files found")
+	}
+	s.logger.Info().Msgf("Checking symlinks for %d files...", len(files))
+	rCloneBase := debridTorrent.MountPath
+	torrentPath, err := s.getTorrentPath(rCloneBase, debridTorrent) // /MyTVShow/
+	// This returns filename.ext for alldebrid instead of the parent folder filename/
+	torrentFolder := torrentPath
+	if err != nil {
+		return "", fmt.Errorf("failed to get torrent path: %v", err)
+	}
+	// Check if the torrent path is a file
+	torrentRclonePath := filepath.Join(rCloneBase, torrentPath) // leave it as is
+	if debridTorrent.Debrid == "alldebrid" && utils.IsMediaFile(torrentPath) {
+		// Alldebrid hotfix for single file torrents
+		torrentFolder = utils.RemoveExtension(torrentFolder)
+		torrentRclonePath = rCloneBase // /mnt/rclone/magnets/  // Remove the filename since it's in the root folder
+	}
+	torrentSymlinkPath := filepath.Join(torrent.SavePath, 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)
+	}
+
+	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 {
+		s.logger.Warn().Msgf("Error while scanning rclone path: %v", err)
+	}
+
+	pending := make(map[string]types.File)
+	for _, file := range files {
+		if realRelPath, ok := realPaths[file.Name]; ok {
+			file.Path = realRelPath
+		}
+		pending[file.Path] = file
+	}
+	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 {
+		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) {
+						s.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
+					} else {
+						filePaths = append(filePaths, fileSymlinkPath)
+						delete(pending, path)
+						s.logger.Info().Msgf("File is ready: %s", file.Name)
+					}
+				}
+			}
+		case <-timeout:
+			s.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 s.skipPreCache {
+		return torrentSymlinkPath, nil
+	}
+
+	go func() {
+		s.logger.Debug().Msgf("Pre-caching %s", debridTorrent.Name)
+		if err := utils.PreCacheFile(filePaths); err != nil {
+			s.logger.Error().Msgf("Failed to pre-cache file: %s", err)
+		} else {
+			s.logger.Trace().Msgf("Pre-cached %d files", len(filePaths))
+		}
+	}()
+	return torrentSymlinkPath, nil
+}
+
+func (s *Store) createSymlinksWebdav(torrent *Torrent, debridTorrent *types.Torrent, rclonePath, torrentFolder string) (string, error) {
+	files := debridTorrent.Files
+	symlinkPath := filepath.Join(torrent.SavePath, 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]types.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) {
+						s.logger.Debug().Msgf("Failed to create symlink: %s: %v", fileSymlinkPath, err)
+					} else {
+						filePaths = append(filePaths, fileSymlinkPath)
+						delete(remainingFiles, filename)
+						s.logger.Info().Msgf("File is ready: %s", file.Name)
+					}
+				}
+			}
+
+		case <-timeout:
+			s.logger.Warn().Msgf("Timeout waiting for files, %d files still pending", len(remainingFiles))
+			return symlinkPath, fmt.Errorf("timeout waiting for files")
+		}
+	}
+
+	if s.skipPreCache {
+		return symlinkPath, nil
+	}
+
+	go func() {
+		s.logger.Debug().Msgf("Pre-caching %s", debridTorrent.Name)
+		if err := utils.PreCacheFile(filePaths); err != nil {
+			s.logger.Error().Msgf("Failed to pre-cache file: %s", err)
+		} else {
+			s.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 (s *Store) getTorrentPath(rclonePath string, debridTorrent *types.Torrent) (string, error) {
+	for {
+		torrentPath, err := debridTorrent.GetMountFolder(rclonePath)
+		if err == nil {
+			s.logger.Debug().Msgf("Found torrent path: %s", torrentPath)
+			return torrentPath, err
+		}
+		time.Sleep(100 * time.Millisecond)
+	}
+}