Wraps up v0.4.1

- Add funding.yml
- Add Arr Queue cleanner worker
- Rewrote worker

.air.toml

@@ -3,9 +3,9 @@ testdata_dir = "testdata"
 tmp_dir = "tmp"
 
 [build]
-  args_bin = []
+  args_bin = ["--config", "data/"]
   bin = "./tmp/main"
-  cmd = "bash -c 'VERSION=$(git describe --tags --always --abbrev=0 2>/dev/null || echo dev) && go build -ldflags \"-X github.com/sirrobot01/debrid-blackhole/pkg/version.Version=$VERSION -X github.com/sirrobot01/debrid-blackhole/pkg/version.Channel=beta\" -o ./tmp/main .'"
+  cmd = "bash -c 'go build -ldflags \"-X github.com/sirrobot01/debrid-blackhole/pkg/version.Version=0.0.4 -X github.com/sirrobot01/debrid-blackhole/pkg/version.Channel=beta\" -o ./tmp/main .'"
   delay = 1000
   exclude_dir = ["assets", "tmp", "vendor", "testdata", "data"]
   exclude_file = []

.dockerignore

@@ -7,3 +7,5 @@ docker-compose.yml
 *.magnet
 **.torrent
 torrents.json
+**/dist/
+*.json

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: sirrobot01
+buy_me_a_coffee: sirrobot01

.gitignore

@@ -12,3 +12,4 @@ dist/
 tmp/**
 torrents.json
 logs/**
+auth.json

CHANGELOG.md

@@ -127,4 +127,13 @@
 - Qbittorrent
   - Add support for tags(creating, deleting, listing)
   - Add support for categories(creating, deleting, listing)
-  - Fix issues with arr sending torrents using a different content type.
+  - Fix issues with arr sending torrents using a different content type.
+
+#### 0.4.1
+
+- Adds optional UI authentication
+- Downloaded Torrents persist on restart
+- Fixes
+    - Fix Alldebrid struggling to find the correct file
+- Minor bug fixes or speed-gains
+- A new cleanup worker to clean up ARR queues

Dockerfile

@@ -1,42 +1,65 @@
-FROM --platform=$BUILDPLATFORM golang:1.22 as builder
+# Stage 1: Build binaries
+FROM --platform=$BUILDPLATFORM golang:1.23-alpine as builder
 
-ARG TARGETPLATFORM
-ARG BUILDPLATFORM
-ARG VERSION
-ARG CHANNEL
+ARG TARGETOS
+ARG TARGETARCH
+ARG VERSION=0.0.0
+ARG CHANNEL=dev
 
-# Set destination for COPY
 WORKDIR /app
 
-# Download Go modules
 COPY go.mod go.sum ./
-RUN go mod download
+RUN --mount=type=cache,target=/go/pkg/mod \
+    go mod download -x
 
-# Copy the source code. Note the slash at the end, as explained in
-# https://docs.docker.com/reference/dockerfile/#copy
-ADD . .
+COPY . .
 
-# Build
-RUN CGO_ENABLED=0 GOOS=$(echo $TARGETPLATFORM | cut -d '/' -f1) GOARCH=$(echo $TARGETPLATFORM | cut -d '/' -f2) go build -ldflags="-X github.com/sirrobot01/debrid-blackhole/pkg/version.Version=${VERSION} -X github.com/sirrobot01/debrid-blackhole/pkg/version.Channel=${CHANNEL}" -o /blackhole
+# Build main binary
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
+    go build -trimpath \
+    -ldflags="-w -s -X github.com/sirrobot01/debrid-blackhole/pkg/version.Version=${VERSION} -X github.com/sirrobot01/debrid-blackhole/pkg/version.Channel=${CHANNEL}" \
+    -o /blackhole
 
-FROM alpine as logsetup
-RUN mkdir -p /logs && \
-    touch /logs/decypharr.log && \
-    chown -R 1000:1000 /logs && \
-    chmod -R 755 /logs && \
-    chmod 666 /logs/decypharr.log
+# Build healthcheck (optimized)
+RUN --mount=type=cache,target=/go/pkg/mod \
+    --mount=type=cache,target=/root/.cache/go-build \
+    CGO_ENABLED=0 GOOS=$TARGETOS GOARCH=$TARGETARCH \
+    go build -trimpath -ldflags="-w -s" \
+    -o /healthcheck cmd/healthcheck/main.go
 
-FROM scratch
-COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
-COPY --from=builder /blackhole /blackhole
-COPY --from=builder /app/README.md /README.md
-COPY --from=logsetup /logs /logs
+# Stage 2: Create directory structure
+FROM alpine:3.19 as dirsetup
+RUN mkdir -p /app/logs && \
+    chmod 777 /app/logs && \
+    touch /app/logs/decypharr.log && \
+    chmod 666 /app/logs/decypharr.log
 
-ENV LOG_PATH=/logs
+# Stage 3: Final image
+FROM gcr.io/distroless/static-debian12:nonroot
 
+LABEL version = "${VERSION}-${CHANNEL}"
+
+LABEL org.opencontainers.image.source = "https://github.com/sirrobot01/debrid-blackhole"
+LABEL org.opencontainers.image.title = "debrid-blackhole"
+LABEL org.opencontainers.image.authors = "sirrobot01"
+LABEL org.opencontainers.image.documentation = "https://github.com/sirrobot01/debrid-blackhole/blob/main/README.md"
+
+# Copy binaries
+COPY --from=builder --chown=nonroot:nonroot /blackhole /usr/bin/blackhole
+COPY --from=builder --chown=nonroot:nonroot /healthcheck /usr/bin/healthcheck
+
+# Copy pre-made directory structure
+COPY --from=dirsetup --chown=nonroot:nonroot /app /app
+
+
+# Metadata
+ENV LOG_PATH=/app/logs
 EXPOSE 8181 8282
-
 VOLUME ["/app"]
+USER nonroot:nonroot
 
-# Run
-CMD ["/blackhole", "--config", "/app/config.json"]
+HEALTHCHECK CMD ["/usr/bin/healthcheck"]
+
+CMD ["/usr/bin/blackhole", "--config", "/app"]

README.md

@@ -1,8 +1,8 @@
-### DecyphArr(with Debrid Proxy Support)
+### DecyphArr(Qbittorent, but with Debrid Proxy Support)
 
 ![ui](doc/main.png)
 
-This is a Golang implementation go Torrent QbitTorrent with a **Multiple Debrid service support**.
+This is an implementation of QbitTorrent with a **Multiple Debrid service support**. Written in Go.
 
 ### Table of Contents
 
@@ -37,7 +37,7 @@ This is a Golang implementation go Torrent QbitTorrent with a **Multiple Debrid
 - Multi-Debrid Providers support
 - Repair Worker for missing files (**NEW**)
 
-The proxy is useful in filtering out un-cached Real Debrid torrents
+The proxy is useful for filtering out un-cached Debrid torrents
 
 ### Supported Debrid Providers
 - [Real Debrid](https://real-debrid.com)
@@ -61,7 +61,7 @@ services:
     user: "1000:1000"
     volumes:
       - /mnt/:/mnt
-      - ~/plex/configs/blackhole/config.json:/app/config.json # Config file, see below
+      - ~/plex/configs/blackhole/:/app # config.json must be in this directory
     environment:
       - PUID=1000
       - PGID=1000
@@ -78,7 +78,7 @@ services:
 Download the binary from the releases page and run it with the config file.
 
 ```bash
-./blackhole --config /path/to/config.json
+./blackhole --config /app
 ```
 
 ### Usage
@@ -99,98 +99,54 @@ Download the binary from the releases page and run it with the config file.
   - Category: e.g `sonarr`, `radarr`
   - Use SSL -> `No`
   - Sequential Download -> `No`|`Yes` (If you want to download the torrents locally instead of symlink)
-  - Test
-  - Save
+  - Click Test
+  - Click Save
 
-#### Sample Config
+#### Basic Sample Config
 
-This is the default config file. You can create a `config.json` file in the root directory of the project or mount it in the docker-compose file.
+This is the default config file. You can create a `config.json` file in the root directory of the project or mount it to /app in the docker-compose file.
 ```json
 {
   "debrids": [
-    {
-      "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": "realdebrid",
       "host": "https://api.real-debrid.com/rest/1.0",
       "api_key": "realdebrid_key",
-      "folder": "/mnt/remote/realdebrid/__all__/",
-      "rate_limit": "250/minute",
-      "download_uncached": false,
-      "check_cached": false
-    },
-    {
-      "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
+      "folder": "/mnt/remote/realdebrid/__all__/"
     }
   ],
   "proxy": {
     "enabled": true,
     "port": "8100",
-    "log_level": "info",
     "username": "username",
-    "password": "password",
-    "cached_only": true
+    "password": "password"
   },
-  "max_cache_size": 1000,
   "qbittorrent": {
     "port": "8282",
     "download_folder": "/mnt/symlinks/",
-    "categories": ["sonarr", "radarr"],
-    "refresh_interval": 5,
-    "log_level": "info"
+    "categories": ["sonarr", "radarr"]
   },
-  "arrs": [
-    {
-      "name": "sonarr",
-      "host": "http://host:8989",
-      "token": "arr_key"
-    },
-    {
-      "name": "radarr",
-      "host": "http://host:7878",
-      "token": "arr_key"
-    }
-  ],
   "repair": {
     "enabled": false,
     "interval": "12h",
     "run_on_start": false
   },
-  "log_level": "info"
+  "use_auth": false
 }
 ```
 
-#### Config Notes
+Full config are [here](doc/config.full.json)
 
-##### Log Level
-- The `log_level` key is used to set the log level of the application. The default value is `info`
-- The log level can be set to `debug`, `info`, `warn`, `error`
-##### Max Cache Size
-- The `max_cache_size` key is used to set the maximum number of infohashes that can be stored in the availability cache. This is used to prevent round trip to the debrid provider when using the proxy/Qbittorrent
-- The default value is `1000`
-- The cache is stored in memory and is not persisted on restart
+<details>
+
+<summary>
+  Click Here for the full config notes
+</summary>
+
+- The `log_level` key is used to set the log level of the application. The default value is `info`. log level can be set to `debug`, `info`, `warn`, `error`
+- The `max_cache_size` key is used to set the maximum number of infohashes that can be stored in the availability cache. This is used to prevent round trip to the debrid provider when using the proxy/Qbittorrent. The default value is `1000`
+- The `allowed_file_types` key is an array of allowed file types that can be downloaded. By default, all movie, tv show and music file types are allowed
+- The `use_auth` is used to enable basic authentication for the UI. The default value is `false`
 
 ##### Debrid Config
 - The `debrids` key is an array of debrid providers
@@ -202,11 +158,13 @@ This is the default config file. You can create a `config.json` file in the root
 - The `download_uncached` bool key is used to download uncached torrents(disabled by default)
 - The `check_cached` bool key is used to check if the torrent is cached(disabled by default)
 
-##### Repair Config (**NEW**)
+##### Repair Config (**BETA**)
 The `repair` key is used to enable the repair worker
 - The `enabled` key is used to enable the repair worker
 - The `interval` key is the interval in either minutes, seconds, hours, days. Use any of this format, e.g 12:00, 5:00, 1h, 1d, 1m, 1s.
 - The `run_on_start` key is used to run the repair worker on start
+- The `zurg_url` is the url of the zurg server. Typically `http://localhost:9999` or `http://zurg:9999`
+- The `skip_deletion`: true if you don't want to delete the files
 
 ##### Proxy Config
 - The `enabled` key is used to enable the proxy
@@ -229,6 +187,9 @@ This is particularly useful if you want to use the Repair tool without using Qbi
 - The `name` key is the name of the Arr/ Category
 - The `host` key is the host of the Arr
 - The `token` key is the API token of the Arr
+- THe `cleanup` key is used to cleanup your arr queues. This is usually for removing dangling queues(downloads that all the files have been import, sometimes, some incomplete season packs)
+
+</details>
 
 
 ### Proxy
@@ -243,6 +204,8 @@ The proxy listens on the port `8181` by default. The username and password can b
 
 The repair worker is a simple worker that checks for missing files in the Arrs(Sonarr, Radarr, etc). It's particularly useful for files either deleted by the Debrid provider or files with bad symlinks.
 
+**Note**: If you're using zurg, set the `zurg_url` under repair config. This will speed up the repair process, exponentially.
+
 - Search for broken symlinks/files
 - Search for missing files
 - Search for deleted/unreadable files
@@ -261,4 +224,4 @@ The repair worker is a simple worker that checks for missing files in the Arrs(S
 - [x] Qbittorrent
   - [x] Add more Qbittorrent features
   - [x] Persist torrents on restart/server crash
-- [ ] Add tests
+- [ ] Add tests

cmd/decypharr/main.go

@@ -0,0 +1,88 @@
+package decypharr
+
+import (
+	"context"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/pkg/proxy"
+	"github.com/sirrobot01/debrid-blackhole/pkg/qbit"
+	"github.com/sirrobot01/debrid-blackhole/pkg/server"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
+	"github.com/sirrobot01/debrid-blackhole/pkg/version"
+	"github.com/sirrobot01/debrid-blackhole/pkg/web"
+	"github.com/sirrobot01/debrid-blackhole/pkg/worker"
+	"log"
+	"sync"
+)
+
+func Start(ctx context.Context) error {
+	cfg := config.GetConfig()
+	var wg sync.WaitGroup
+	errChan := make(chan error)
+
+	_log := logger.GetLogger(cfg.LogLevel)
+
+	_log.Info().Msgf("Version: %s", version.GetInfo().String())
+	_log.Debug().Msgf("Config Loaded: %s", cfg.JsonFile())
+	_log.Debug().Msgf("Default Log Level: %s", cfg.LogLevel)
+
+	svc := service.New()
+	_qbit := qbit.New()
+	srv := server.New()
+	webRoutes := web.New(_qbit).Routes()
+	qbitRoutes := _qbit.Routes()
+
+	// Register routes
+	srv.Mount("/", webRoutes)
+	srv.Mount("/api/v2", qbitRoutes)
+
+	if cfg.Proxy.Enabled {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := proxy.NewProxy().Start(ctx); err != nil {
+				errChan <- err
+			}
+		}()
+	}
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		if err := srv.Start(ctx); err != nil {
+			errChan <- err
+		}
+
+	}()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		if err := worker.Start(ctx); err != nil {
+			errChan <- err
+		}
+	}()
+
+	if cfg.Repair.Enabled {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := svc.Repair.Start(ctx); err != nil {
+				log.Printf("Error during repair: %v", err)
+			}
+		}()
+	}
+
+	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()
+	}
+}

cmd/healthcheck/main.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"cmp"
+	"net/http"
+	"os"
+)
+
+func main() {
+	port := cmp.Or(os.Getenv("QBIT_PORT"), "8282")
+	resp, err := http.Get("http://localhost:" + port + "/api/v2/app/version")
+	if err != nil {
+		os.Exit(1)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		os.Exit(1)
+	}
+
+	os.Exit(0)
+}

cmd/main.go

@@ -1,66 +0,0 @@
-package cmd
-
-import (
-	"cmp"
-	"context"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/proxy"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit"
-	"github.com/sirrobot01/debrid-blackhole/pkg/repair"
-	"log"
-	"sync"
-)
-
-func Start(ctx context.Context, config *common.Config) error {
-	maxCacheSize := cmp.Or(config.MaxCacheSize, 1000)
-
-	deb := debrid.NewDebrid(config.Debrids, maxCacheSize)
-	arrs := arr.NewStorage(config.Arrs)
-
-	var wg sync.WaitGroup
-	errChan := make(chan error, 2)
-
-	if config.Proxy.Enabled {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := proxy.NewProxy(*config, deb).Start(ctx); err != nil {
-				errChan <- err
-			}
-		}()
-	}
-	if config.QBitTorrent.Port != "" {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := qbit.Start(ctx, config, deb, arrs); err != nil {
-				errChan <- err
-			}
-		}()
-	}
-
-	if config.Repair.Enabled {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			if err := repair.Start(ctx, config, arrs); err != nil {
-				log.Printf("Error during repair: %v", err)
-			}
-		}()
-	}
-
-	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()
-	}
-}

common/config.go

@@ -1,172 +0,0 @@
-package common
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"log"
-	"os"
-	"sync"
-)
-
-type DebridConfig struct {
-	Name             string `json:"name"`
-	Host             string `json:"host"`
-	APIKey           string `json:"api_key"`
-	Folder           string `json:"folder"`
-	DownloadUncached bool   `json:"download_uncached"`
-	CheckCached      bool   `json:"check_cached"`
-	RateLimit        string `json:"rate_limit"` // 200/minute or 10/second
-}
-
-type ProxyConfig struct {
-	Port       string `json:"port"`
-	Enabled    bool   `json:"enabled"`
-	LogLevel   string `json:"log_level"`
-	Username   string `json:"username"`
-	Password   string `json:"password"`
-	CachedOnly *bool  `json:"cached_only"`
-}
-
-type QBitTorrentConfig struct {
-	Username        string   `json:"username"`
-	Password        string   `json:"password"`
-	Port            string   `json:"port"`
-	LogLevel        string   `json:"log_level"`
-	DownloadFolder  string   `json:"download_folder"`
-	Categories      []string `json:"categories"`
-	RefreshInterval int      `json:"refresh_interval"`
-}
-
-type ArrConfig struct {
-	Name  string `json:"name"`
-	Host  string `json:"host"`
-	Token string `json:"token"`
-}
-
-type RepairConfig struct {
-	Enabled    bool   `json:"enabled"`
-	Interval   string `json:"interval"`
-	RunOnStart bool   `json:"run_on_start"`
-}
-
-type Config struct {
-	LogLevel     string            `json:"log_level"`
-	Debrid       DebridConfig      `json:"debrid"`
-	Debrids      []DebridConfig    `json:"debrids"`
-	Proxy        ProxyConfig       `json:"proxy"`
-	MaxCacheSize int               `json:"max_cache_size"`
-	QBitTorrent  QBitTorrentConfig `json:"qbittorrent"`
-	Arrs         []ArrConfig       `json:"arrs"`
-	Repair       RepairConfig      `json:"repair"`
-}
-
-func validateDebrids(debrids []DebridConfig) error {
-	if len(debrids) == 0 {
-		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 concurrently
-		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 first error if any
-	if err := <-errChan; err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func validateQbitTorrent(config *QBitTorrentConfig) error {
-	if config.DownloadFolder == "" {
-		return errors.New("qbittorent download folder is required")
-	}
-	if _, err := os.Stat(config.DownloadFolder); os.IsNotExist(err) {
-		return errors.New("qbittorent download folder does not exist")
-	}
-	return nil
-}
-
-func validateConfig(config *Config) error {
-	// Run validations concurrently
-	errChan := make(chan error, 2)
-
-	go func() {
-		errChan <- validateDebrids(config.Debrids)
-	}()
-
-	go func() {
-		errChan <- validateQbitTorrent(&config.QBitTorrent)
-	}()
-
-	// Check for errors
-	for i := 0; i < 2; i++ {
-		if err := <-errChan; err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func LoadConfig(path string) (*Config, error) {
-	// Load the config file
-	file, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer func(file *os.File) {
-		err := file.Close()
-		if err != nil {
-			log.Fatal(err)
-		}
-	}(file)
-
-	decoder := json.NewDecoder(file)
-	config := &Config{}
-	err = decoder.Decode(config)
-	if err != nil {
-		return nil, err
-	}
-
-	if config.Debrid.Name != "" {
-		config.Debrids = append(config.Debrids, config.Debrid)
-	}
-
-	// Validate the config
-	//if err := validateConfig(config); err != nil {
-	//	return nil, err
-	//}
-
-	return config, nil
-}
-
-var CONFIG *Config = nil

common/regex.go

@@ -1,59 +0,0 @@
-package common
-
-import (
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-var (
-	VIDEOMATCH  = "(?i)(\\.)(YUV|WMV|WEBM|VOB|VIV|SVI|ROQ|RMVB|RM|OGV|OGG|NSV|MXF|MPG|MPEG|M2V|MP2|MPE|MPV|MP4|M4P|M4V|MOV|QT|MNG|MKV|FLV|DRC|AVI|ASF|AMV|MKA|F4V|3GP|3G2|DIVX|X264|X265)$"
-	MUSICMATCH  = "(?i)(\\.)(?:MP3|WAV|FLAC|AAC|OGG|WMA|AIFF|ALAC|M4A|APE|AC3|DTS|M4P|MID|MIDI|MKA|MP2|MPA|RA|VOC|WV|AMR)$"
-	SUBMATCH    = "(?i)(\\.)(SRT|SUB|SBV|ASS|VTT|TTML|DFXP|STL|SCC|CAP|SMI|TTXT|TDS|USF|JSS|SSA|PSB|RT|LRC|SSB)$"
-	SAMPLEMATCH = `(?i)(^|[\\/]|[._-])(sample|trailer|thumb)s?([._-]|$)`
-)
-
-func RegexMatch(regex string, value string) bool {
-	re := regexp.MustCompile(regex)
-	return re.MatchString(value)
-}
-
-func RemoveInvalidChars(value string) string {
-	return strings.Map(func(r rune) rune {
-		if r == filepath.Separator || r == ':' {
-			return r
-		}
-		if filepath.IsAbs(string(r)) {
-			return r
-		}
-		if strings.ContainsRune(filepath.VolumeName("C:"+string(r)), r) {
-			return r
-		}
-		if r < 32 || strings.ContainsRune(`<>:"/\|?*`, r) {
-			return -1
-		}
-		return r
-	}, value)
-}
-
-func RemoveExtension(value string) string {
-	re := regexp.MustCompile(VIDEOMATCH + "|" + SUBMATCH + "|" + SAMPLEMATCH + "|" + MUSICMATCH)
-
-	// Find the last index of the matched extension
-	loc := re.FindStringIndex(value)
-	if loc != nil {
-		return value[:loc[0]]
-	} else {
-		return value
-	}
-}
-
-func RegexFind(regex string, value string) string {
-	re := regexp.MustCompile(regex)
-	match := re.FindStringSubmatch(value)
-	if len(match) > 0 {
-		return match[0]
-	} else {
-		return ""
-	}
-}

doc/config.full.json

@@ -0,0 +1,82 @@
+{
+  "debrids": [
+    {
+      "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": "realdebrid",
+      "host": "https://api.real-debrid.com/rest/1.0",
+      "api_key": "realdebrid_key",
+      "folder": "/mnt/remote/realdebrid/__all__/",
+      "rate_limit": "250/minute",
+      "download_uncached": false,
+      "check_cached": false
+    },
+    {
+      "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
+    }
+  ],
+  "proxy": {
+    "enabled": true,
+    "port": "8100",
+    "log_level": "info",
+    "username": "username",
+    "password": "password",
+    "cached_only": true
+  },
+  "max_cache_size": 1000,
+  "qbittorrent": {
+    "port": "8282",
+    "download_folder": "/mnt/symlinks/",
+    "categories": ["sonarr", "radarr"],
+    "refresh_interval": 5,
+    "log_level": "info"
+  },
+  "arrs": [
+    {
+      "name": "sonarr",
+      "host": "http://host:8989",
+      "token": "arr_key",
+      "cleanup": false
+    },
+    {
+      "name": "radarr",
+      "host": "http://host:7878",
+      "token": "arr_key",
+      "cleanup": false
+    }
+  ],
+  "repair": {
+    "enabled": false,
+    "interval": "12h",
+    "run_on_start": false,
+    "zurg_url": "http://zurg:9999",
+    "skip_deletion": false
+  },
+  "log_level": "info",
+  "min_file_size": "",
+  "max_file_size": "",
+  "allowed_file_types": [],
+  "use_auth": false
+}

go.mod

@@ -1,6 +1,8 @@
 module github.com/sirrobot01/debrid-blackhole
 
-go 1.22
+go 1.23
+
+toolchain go1.23.2
 
 require (
 	github.com/anacrolix/torrent v1.55.0
@@ -9,25 +11,28 @@ require (
 	github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2
 	github.com/go-chi/chi/v5 v5.1.0
 	github.com/google/uuid v1.6.0
-	github.com/valyala/fasthttp v1.55.0
+	github.com/gorilla/sessions v1.4.0
+	github.com/rs/zerolog v1.33.0
 	github.com/valyala/fastjson v1.6.4
-	golang.org/x/time v0.6.0
+	golang.org/x/crypto v0.33.0
+	golang.org/x/net v0.33.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/andybalholm/brotli v1.1.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/klauspost/compress v1.17.9 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
-	github.com/rs/zerolog v1.33.0 // indirect
-	github.com/valyala/bytebufferpool v1.0.0 // indirect
-	golang.org/x/net v0.27.0 // indirect
-	golang.org/x/sys v0.22.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	gopkg.in/natefinch/lumberjack.v2 v2.2.1 // 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.12.0 // 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

@@ -35,8 +35,6 @@ github.com/anacrolix/tagflag v1.0.0/go.mod h1:1m2U/K6ZT+JZG0+bdMK6qauP49QT4wE5pm
 github.com/anacrolix/tagflag v1.1.0/go.mod h1:Scxs9CV10NQatSmbyjqmqmeQNwGzlNe0CMUMIxqHIG8=
 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/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
-github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
 github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ=
 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=
@@ -52,8 +50,9 @@ github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE=
 github.com/dustin/go-humanize v0.0.0-20180421182945-02af3965c54e/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -106,6 +105,8 @@ github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
+github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
@@ -114,6 +115,10 @@ github.com/gopherjs/gopherjs v0.0.0-20190309154008-847fc94819f9/go.mod h1:wJfORR
 github.com/gopherjs/gopherjs v0.0.0-20190910122728-9d188e94fb99/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/context v1.1.1/go.mod h1:kBGZzfjB9CEq2AlWe17Uuf7NDRt0dE0s8S51q0aT7Yg=
 github.com/gorilla/mux v1.6.2/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=
+github.com/gorilla/securecookie v1.1.2 h1:YCIWL56dvtr73r6715mJs5ZvhtnY73hBvEF8kXD8ePA=
+github.com/gorilla/securecookie v1.1.2/go.mod h1:NfCASbcHqRSY+3a8tlWJwsQap2VX5pwzwo4h3eOamfo=
+github.com/gorilla/sessions v1.4.0 h1:kpIYOp/oi6MG/p5PgxApU8srsSw9tuFbt46Lt7auzqQ=
+github.com/gorilla/sessions v1.4.0/go.mod h1:FLWm50oby91+hl7p/wRxDth9bWSuk0qVL2emc7lT5ik=
 github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
 github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
 github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo=
@@ -127,8 +132,6 @@ github.com/jtolds/gls v4.2.1+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVY
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
@@ -141,8 +144,9 @@ github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
 github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
 github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
@@ -160,8 +164,9 @@ github.com/pierrec/lz4 v2.0.5+incompatible/go.mod h1:pdkljMzZIN41W+lC3N2tnIh5sFi
 github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
 github.com/prometheus/client_golang v0.9.3-0.20190127221311-3c4408c8b829/go.mod h1:p2iRAGwDERtqlqzRXnrOVns+ignqQo//hLXqYxZYVNs=
 github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
@@ -180,8 +185,8 @@ github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+Gx
 github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 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/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8=
+github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4=
 github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
 github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
 github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
@@ -198,15 +203,11 @@ github.com/stretchr/testify v1.2.1/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXf
 github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
-github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKsk=
-github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 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/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
-github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.55.0 h1:Zkefzgt6a7+bVKHnu/YaYSOPfNYNisSVBo/unVCf8k8=
-github.com/valyala/fasthttp v1.55.0/go.mod h1:NkY9JtkrpPKmgwV3HTaS2HWaJss9RSIsRVfcxxoHiOM=
 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=
@@ -216,6 +217,8 @@ go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 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=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
 golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
 golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
 golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
@@ -231,8 +234,8 @@ golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73r
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190613194153-d28f0bde5980/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
-golang.org/x/net v0.27.0/go.mod h1:dDi0PyhWNoiUOrAS8uXv/vnScO4wnHQO4mj9fn/RytE=
+golang.org/x/net v0.33.0 h1:74SYHlV8BIgHIFC/LrYkOGIwL19eTYXQ5wc6TBuO36I=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
@@ -254,14 +257,14 @@ golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
-golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+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.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U=
-golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
+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/cache/cache.go

@@ -1,4 +1,4 @@
-package common
+package cache
 
 import (
 	"sync"
@@ -11,7 +11,7 @@ type Cache struct {
 	mu       sync.RWMutex
 }
 
-func NewCache(maxItems int) *Cache {
+func New(maxItems int) *Cache {
 	if maxItems <= 0 {
 		maxItems = 1000
 	}

internal/config/config.go

@@ -0,0 +1,287 @@
+package config
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+var (
+	instance   *Config
+	once       sync.Once
+	configPath string
+)
+
+type Debrid struct {
+	Name             string `json:"name"`
+	Host             string `json:"host"`
+	APIKey           string `json:"api_key"`
+	Folder           string `json:"folder"`
+	DownloadUncached bool   `json:"download_uncached"`
+	CheckCached      bool   `json:"check_cached"`
+	RateLimit        string `json:"rate_limit"` // 200/minute or 10/second
+}
+
+type Proxy struct {
+	Port       string `json:"port"`
+	Enabled    bool   `json:"enabled"`
+	LogLevel   string `json:"log_level"`
+	Username   string `json:"username"`
+	Password   string `json:"password"`
+	CachedOnly bool   `json:"cached_only"`
+}
+
+type QBitTorrent struct {
+	Username        string   `json:"username"`
+	Password        string   `json:"password"`
+	Port            string   `json:"port"`
+	LogLevel        string   `json:"log_level"`
+	DownloadFolder  string   `json:"download_folder"`
+	Categories      []string `json:"categories"`
+	RefreshInterval int      `json:"refresh_interval"`
+}
+
+type Arr struct {
+	Name    string `json:"name"`
+	Host    string `json:"host"`
+	Token   string `json:"token"`
+	Cleanup bool   `json:"cleanup"`
+}
+
+type Repair struct {
+	Enabled      bool   `json:"enabled"`
+	Interval     string `json:"interval"`
+	RunOnStart   bool   `json:"run_on_start"`
+	ZurgURL      string `json:"zurg_url"`
+	SkipDeletion bool   `json:"skip_deletion"`
+}
+
+type Auth struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+type Config struct {
+	LogLevel     string      `json:"log_level"`
+	Debrid       Debrid      `json:"debrid"`
+	Debrids      []Debrid    `json:"debrids"`
+	Proxy        Proxy       `json:"proxy"`
+	MaxCacheSize int         `json:"max_cache_size"`
+	QBitTorrent  QBitTorrent `json:"qbittorrent"`
+	Arrs         []Arr       `json:"arrs"`
+	Repair       Repair      `json:"repair"`
+	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:"-"`
+}
+
+func (c *Config) JsonFile() string {
+	return filepath.Join(c.Path, "config.json")
+}
+func (c *Config) AuthFile() string {
+	return filepath.Join(c.Path, "auth.json")
+}
+
+func (c *Config) loadConfig() error {
+	// Load the config file
+	if configPath == "" {
+		return fmt.Errorf("config path not set")
+	}
+	c.Path = configPath
+	file, err := os.ReadFile(c.JsonFile())
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(file, &c); err != nil {
+		return fmt.Errorf("error unmarshaling config: %w", err)
+	}
+
+	if c.Debrid.Name != "" {
+		c.Debrids = append(c.Debrids, c.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
+	//}
+
+	return nil
+}
+
+func validateDebrids(debrids []Debrid) error {
+	if len(debrids) == 0 {
+		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 concurrently
+		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 first error if any
+	if err := <-errChan; 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 errors.New("qbittorent download folder does not exist")
+	}
+	return nil
+}
+
+func validateConfig(config *Config) error {
+	// Run validations concurrently
+	errChan := make(chan error, 2)
+
+	go func() {
+		errChan <- validateDebrids(config.Debrids)
+	}()
+
+	go func() {
+		errChan <- validateQbitTorrent(&config.QBitTorrent)
+	}()
+
+	// Check for errors
+	for i := 0; i < 2; i++ {
+		if err := <-errChan; err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func SetConfigPath(path string) error {
+	configPath = path
+	return nil
+}
+
+func GetConfig() *Config {
+	once.Do(func() {
+		instance = &Config{} // Initialize instance first
+		if err := instance.loadConfig(); err != nil {
+			_, err := fmt.Fprintf(os.Stderr, "configuration Error: %v\n", err)
+			if err != nil {
+				return
+			}
+			os.Exit(1)
+		}
+	})
+	return instance
+}
+
+func (c *Config) GetMinFileSize() int64 {
+	// 0 means no limit
+	if c.MinFileSize == "" {
+		return 0
+	}
+	s, err := parseSize(c.MinFileSize)
+	if err != nil {
+		return 0
+	}
+	return s
+}
+
+func (c *Config) GetMaxFileSize() int64 {
+	// 0 means no limit
+	if c.MaxFileSize == "" {
+		return 0
+	}
+	s, err := parseSize(c.MaxFileSize)
+	if err != nil {
+		return 0
+	}
+	return s
+}
+
+func (c *Config) IsSizeAllowed(size int64) bool {
+	if size == 0 {
+		return true // Maybe the debrid hasn't reported the size yet
+	}
+	if c.GetMinFileSize() > 0 && size < c.GetMinFileSize() {
+		return false
+	}
+	if c.GetMaxFileSize() > 0 && size > c.GetMaxFileSize() {
+		return false
+	}
+	return true
+}
+
+func (c *Config) GetAuth() *Auth {
+	if !c.UseAuth {
+		return nil
+	}
+	if c.Auth == nil {
+		c.Auth = &Auth{}
+		if _, err := os.Stat(c.AuthFile()); err == nil {
+			file, err := os.ReadFile(c.AuthFile())
+			if err == nil {
+				_ = json.Unmarshal(file, c.Auth)
+			}
+		}
+	}
+	return c.Auth
+}
+
+func (c *Config) SaveAuth(auth *Auth) error {
+	c.Auth = auth
+	data, err := json.Marshal(auth)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(c.AuthFile(), data, 0644)
+}
+
+func (c *Config) NeedsSetup() bool {
+	if c.UseAuth {
+		return c.GetAuth().Username == ""
+	}
+	return false
+}

internal/config/misc.go

@@ -0,0 +1,75 @@
+package config
+
+import (
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+func (c *Config) IsAllowedFile(filename string) bool {
+	ext := strings.ToLower(filepath.Ext(filename))
+	if ext == "" {
+		return false
+	}
+	// Remove the leading dot
+	ext = ext[1:]
+
+	for _, allowed := range c.AllowedExt {
+		if ext == allowed {
+			return true
+		}
+	}
+	return false
+}
+
+func getDefaultExtensions() []string {
+	videoExts := strings.Split("YUV,WMV,WEBM,VOB,VIV,SVI,ROQ,RMVB,RM,OGV,OGG,NSV,MXF,MPG,MPEG,M2V,MP2,MPE,MPV,MP4,M4P,M4V,MOV,QT,MNG,MKV,FLV,DRC,AVI,ASF,AMV,MKA,F4V,3GP,3G2,DIVX,X264,X265", ",")
+	musicExts := strings.Split("MP3,WAV,FLAC,AAC,OGG,WMA,AIFF,ALAC,M4A,APE,AC3,DTS,M4P,MID,MIDI,MKA,MP2,MPA,RA,VOC,WV,AMR", ",")
+
+	// Combine both slices
+	allExts := append(videoExts, musicExts...)
+
+	// Convert to lowercase
+	for i, ext := range allExts {
+		allExts[i] = strings.ToLower(ext)
+	}
+
+	// Remove duplicates
+	seen := make(map[string]bool)
+	var unique []string
+
+	for _, ext := range allExts {
+		if !seen[ext] {
+			seen[ext] = true
+			unique = append(unique, ext)
+		}
+	}
+
+	sort.Strings(unique)
+	return unique
+}
+
+func parseSize(sizeStr string) (int64, error) {
+	sizeStr = strings.ToUpper(strings.TrimSpace(sizeStr))
+
+	// Absolute size-based cache
+	multiplier := 1.0
+	if strings.HasSuffix(sizeStr, "GB") {
+		multiplier = 1024 * 1024 * 1024
+		sizeStr = strings.TrimSuffix(sizeStr, "GB")
+	} else if strings.HasSuffix(sizeStr, "MB") {
+		multiplier = 1024 * 1024
+		sizeStr = strings.TrimSuffix(sizeStr, "MB")
+	} else if strings.HasSuffix(sizeStr, "KB") {
+		multiplier = 1024
+		sizeStr = strings.TrimSuffix(sizeStr, "KB")
+	}
+
+	size, err := strconv.ParseFloat(sizeStr, 64)
+	if err != nil {
+		return 0, err
+	}
+
+	return int64(size * multiplier), nil
+}

internal/logger/logger.go

@@ -1,23 +1,29 @@
-package common
+package logger
 
 import (
 	"fmt"
 	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
 	"gopkg.in/natefinch/lumberjack.v2"
 	"os"
 	"path/filepath"
 	"strings"
+	"sync"
+)
+
+var (
+	once   sync.Once
+	logger zerolog.Logger
 )
 
 func GetLogPath() string {
-	logsDir := os.Getenv("LOG_PATH")
-	if logsDir == "" {
-		// Create the logs directory if it doesn't exist
-		logsDir = "logs"
-	}
+	cfg := config.GetConfig()
+	logsDir := filepath.Join(cfg.Path, "logs")
 
-	if err := os.MkdirAll(logsDir, 0755); err != nil {
-		panic(fmt.Sprintf("Failed to create logs directory: %v", err))
+	if _, err := os.Stat(logsDir); os.IsNotExist(err) {
+		if err := os.MkdirAll(logsDir, 0755); err != nil {
+			panic(fmt.Sprintf("Failed to create logs directory: %v", err))
+		}
 	}
 
 	return filepath.Join(logsDir, "decypharr.log")
@@ -27,7 +33,7 @@ func NewLogger(prefix string, level string, output *os.File) zerolog.Logger {
 
 	rotatingLogFile := &lumberjack.Logger{
 		Filename:   GetLogPath(),
-		MaxSize:    10,
+		MaxSize:    2,
 		MaxBackups: 2,
 		MaxAge:     28,
 		Compress:   true,
@@ -78,3 +84,10 @@ func NewLogger(prefix string, level string, output *os.File) zerolog.Logger {
 	}
 	return logger
 }
+
+func GetLogger(level string) zerolog.Logger {
+	once.Do(func() {
+		logger = NewLogger("decypharr", level, os.Stdout)
+	})
+	return logger
+}

internal/request/request.go

@@ -1,4 +1,4 @@
-package common
+package request
 
 import (
 	"crypto/tls"
@@ -8,11 +8,32 @@ import (
 	"io"
 	"log"
 	"net/http"
+	"net/url"
 	"regexp"
 	"strconv"
+	"strings"
 	"time"
 )
 
+func JoinURL(base string, paths ...string) (string, error) {
+	// Split the last path component to separate query parameters
+	lastPath := paths[len(paths)-1]
+	parts := strings.Split(lastPath, "?")
+	paths[len(paths)-1] = parts[0]
+
+	joined, err := url.JoinPath(base, paths...)
+	if err != nil {
+		return "", err
+	}
+
+	// Add back query parameters if they exist
+	if len(parts) > 1 {
+		return joined + "?" + parts[1], nil
+	}
+
+	return joined, nil
+}
+
 type RLHTTPClient struct {
 	client      *http.Client
 	Ratelimiter *rate.Limiter
@@ -72,25 +93,32 @@ func (c *RLHTTPClient) MakeRequest(req *http.Request) ([]byte, error) {
 	if err != nil {
 		return nil, err
 	}
-	b, _ := io.ReadAll(res.Body)
-	statusOk := strconv.Itoa(res.StatusCode)[0] == '2'
-	if !statusOk {
-		// Add status code error to the body
-		b = append(b, []byte(fmt.Sprintf("\nstatus code: %d", res.StatusCode))...)
-		return nil, fmt.Errorf(string(b))
-	}
+
 	defer func(Body io.ReadCloser) {
 		err := Body.Close()
 		if err != nil {
 			log.Println(err)
 		}
 	}(res.Body)
+
+	b, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, err
+	}
+	statusOk := res.StatusCode >= 200 && res.StatusCode < 300
+	if !statusOk {
+		// Add status code error to the body
+		b = append(b, []byte(fmt.Sprintf("\nstatus code: %d", res.StatusCode))...)
+		return nil, fmt.Errorf(string(b))
+	}
+
 	return b, nil
 }
 
 func NewRLHTTPClient(rl *rate.Limiter, headers map[string]string) *RLHTTPClient {
 	tr := &http.Transport{
 		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		Proxy:           http.ProxyFromEnvironment,
 	}
 	c := &RLHTTPClient{
 		client: &http.Client{

internal/utils/file.go

@@ -0,0 +1,2 @@
+package utils
+

internal/utils/magnet.go

@@ -1,7 +1,8 @@
-package common
+package utils
 
 import (
 	"bufio"
+	"bytes"
 	"context"
 	"encoding/base32"
 	"encoding/hex"
@@ -9,7 +10,6 @@ import (
 	"github.com/anacrolix/torrent/metainfo"
 	"io"
 	"log"
-	"math/rand"
 	"net/http"
 	"net/url"
 	"os"
@@ -28,23 +28,11 @@ type Magnet struct {
 
 func GetMagnetFromFile(file io.Reader, filePath string) (*Magnet, error) {
 	if filepath.Ext(filePath) == ".torrent" {
-		mi, err := metainfo.Load(file)
+		torrentData, err := io.ReadAll(file)
 		if err != nil {
 			return nil, err
 		}
-		hash := mi.HashInfoBytes()
-		infoHash := hash.HexString()
-		info, err := mi.UnmarshalInfo()
-		if err != nil {
-			return nil, err
-		}
-		magnet := &Magnet{
-			InfoHash: infoHash,
-			Name:     info.Name,
-			Size:     info.Length,
-			Link:     mi.Magnet(&hash, &info).String(),
-		}
-		return magnet, nil
+		return GetMagnetFromBytes(torrentData)
 	} else {
 		// .magnet file
 		magnetLink := ReadMagnetFile(file)
@@ -61,6 +49,28 @@ func GetMagnetFromUrl(url string) (*Magnet, error) {
 	return nil, fmt.Errorf("invalid url")
 }
 
+func GetMagnetFromBytes(torrentData []byte) (*Magnet, error) {
+	// Create a scanner to read the file line by line
+	mi, err := metainfo.Load(bytes.NewReader(torrentData))
+	if err != nil {
+		return nil, err
+	}
+	hash := mi.HashInfoBytes()
+	infoHash := hash.HexString()
+	info, err := mi.UnmarshalInfo()
+	if err != nil {
+		return nil, err
+	}
+	log.Println("InfoHash: ", infoHash)
+	magnet := &Magnet{
+		InfoHash: infoHash,
+		Name:     info.Name,
+		Size:     info.Length,
+		Link:     mi.Magnet(&hash, &info).String(),
+	}
+	return magnet, nil
+}
+
 func OpenMagnetFile(filePath string) string {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -103,27 +113,11 @@ func OpenMagnetHttpURL(magnetLink string) (*Magnet, error) {
 			return
 		}
 	}(resp) // Ensure the response is closed after the function ends
-
-	// Create a scanner to read the file line by line
-
-	mi, err := metainfo.Load(resp.Body)
+	torrentData, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("error reading response body: %v", err)
 	}
-	hash := mi.HashInfoBytes()
-	infoHash := hash.HexString()
-	info, err := mi.UnmarshalInfo()
-	if err != nil {
-		return nil, err
-	}
-	log.Println("InfoHash: ", infoHash)
-	magnet := &Magnet{
-		InfoHash: infoHash,
-		Name:     info.Name,
-		Size:     info.Length,
-		Link:     mi.Magnet(&hash, &info).String(),
-	}
-	return magnet, nil
+	return GetMagnetFromBytes(torrentData)
 }
 
 func GetMagnetInfo(magnetLink string) (*Magnet, error) {
@@ -155,15 +149,6 @@ func GetMagnetInfo(magnetLink string) (*Magnet, error) {
 	return magnet, nil
 }
 
-func RandomString(length int) string {
-	const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
-	b := make([]byte, length)
-	for i := range b {
-		b[i] = charset[rand.Intn(len(charset))]
-	}
-	return string(b)
-}
-
 func ExtractInfoHash(magnetDesc string) string {
 	const prefix = "xt=urn:btih:"
 	start := strings.Index(magnetDesc, prefix)
@@ -248,41 +233,3 @@ func GetInfohashFromURL(url string) (string, error) {
 	infoHash := hash.HexString()
 	return infoHash, nil
 }
-
-func JoinURL(base string, paths ...string) (string, error) {
-	// Split the last path component to separate query parameters
-	lastPath := paths[len(paths)-1]
-	parts := strings.Split(lastPath, "?")
-	paths[len(paths)-1] = parts[0]
-
-	joined, err := url.JoinPath(base, paths...)
-	if err != nil {
-		return "", err
-	}
-
-	// Add back query parameters if they exist
-	if len(parts) > 1 {
-		return joined + "?" + parts[1], nil
-	}
-
-	return joined, nil
-}
-
-func FileReady(path string) bool {
-	_, err := os.Stat(path)
-	return !os.IsNotExist(err) // Returns true if the file exists
-}
-
-func Remove[S ~[]E, E comparable](s S, values ...E) S {
-	result := make(S, 0, len(s))
-outer:
-	for _, item := range s {
-		for _, v := range values {
-			if item == v {
-				continue outer
-			}
-		}
-		result = append(result, item)
-	}
-	return result
-}

internal/utils/misc.go

@@ -0,0 +1,15 @@
+package utils
+
+func RemoveItem[S ~[]E, E comparable](s S, values ...E) S {
+	result := make(S, 0, len(s))
+outer:
+	for _, item := range s {
+		for _, v := range values {
+			if item == v {
+				continue outer
+			}
+		}
+		result = append(result, item)
+	}
+	return result
+}

internal/utils/regex.go

@@ -0,0 +1,58 @@
+package utils
+
+import (
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+var (
+	VIDEOMATCH = "(?i)(\\.)(YUV|WMV|WEBM|VOB|VIV|SVI|ROQ|RMVB|RM|OGV|OGG|NSV|MXF|MPG|MPEG|M2V|MP2|MPE|MPV|MP4|M4P|M4V|MOV|QT|MNG|MKV|FLV|DRC|AVI|ASF|AMV|MKA|F4V|3GP|3G2|DIVX|X264|X265)$"
+	MUSICMATCH = "(?i)(\\.)(?:MP3|WAV|FLAC|AAC|OGG|WMA|AIFF|ALAC|M4A|APE|AC3|DTS|M4P|MID|MIDI|MKA|MP2|MPA|RA|VOC|WV|AMR)$"
+)
+
+var SAMPLEMATCH = `(?i)(^|[\\/]|[._-])(sample|trailer|thumb)s?([._-]|$)`
+
+func RegexMatch(regex string, value string) bool {
+	re := regexp.MustCompile(regex)
+	return re.MatchString(value)
+}
+
+func RemoveInvalidChars(value string) string {
+	return strings.Map(func(r rune) rune {
+		if r == filepath.Separator || r == ':' {
+			return r
+		}
+		if filepath.IsAbs(string(r)) {
+			return r
+		}
+		if strings.ContainsRune(filepath.VolumeName("C:"+string(r)), r) {
+			return r
+		}
+		if r < 32 || strings.ContainsRune(`<>:"/\|?*`, r) {
+			return -1
+		}
+		return r
+	}, value)
+}
+
+func RemoveExtension(value string) string {
+	re := regexp.MustCompile(VIDEOMATCH + "|" + SAMPLEMATCH + "|" + MUSICMATCH)
+
+	// Find the last index of the matched extension
+	loc := re.FindStringIndex(value)
+	if loc != nil {
+		return value[:loc[0]]
+	} else {
+		return value
+	}
+}
+
+func IsMediaFile(path string) bool {
+	mediaPattern := VIDEOMATCH + "|" + MUSICMATCH
+	return RegexMatch(mediaPattern, path)
+}
+
+func IsSampleFile(path string) bool {
+	return RegexMatch(SAMPLEMATCH, path)
+}

main.go

@@ -3,24 +3,22 @@ package main
 import (
 	"context"
 	"flag"
-	"github.com/sirrobot01/debrid-blackhole/cmd"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/cmd/decypharr"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
 	"log"
 )
 
 func main() {
 	var configPath string
-	flag.StringVar(&configPath, "config", "config.json", "path to the config file")
+	flag.StringVar(&configPath, "config", "/data", "path to the data folder")
 	flag.Parse()
 
-	// Load the config file
-	conf, err := common.LoadConfig(configPath)
-	common.CONFIG = conf
-	if err != nil {
+	if err := config.SetConfigPath(configPath); err != nil {
 		log.Fatal(err)
 	}
+	config.GetConfig()
 	ctx := context.Background()
-	if err := cmd.Start(ctx, conf); err != nil {
+	if err := decypharr.Start(ctx); err != nil {
 		log.Fatal(err)
 	}
 

pkg/arr/arr.go

@@ -3,7 +3,8 @@ package arr
 import (
 	"bytes"
 	"encoding/json"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
 	"net/http"
 	"strings"
 	"sync"
@@ -20,22 +21,24 @@ const (
 )
 
 var (
-	client *common.RLHTTPClient = common.NewRLHTTPClient(nil, nil)
+	client *request.RLHTTPClient = request.NewRLHTTPClient(nil, nil)
 )
 
 type Arr struct {
-	Name  string `json:"name"`
-	Host  string `json:"host"`
-	Token string `json:"token"`
-	Type  Type   `json:"type"`
+	Name    string `json:"name"`
+	Host    string `json:"host"`
+	Token   string `json:"token"`
+	Type    Type   `json:"type"`
+	Cleanup bool   `json:"cleanup"`
 }
 
-func NewArr(name, host, token string, arrType Type) *Arr {
+func New(name, host, token string, cleanup bool) *Arr {
 	return &Arr{
-		Name:  name,
-		Host:  host,
-		Token: token,
-		Type:  arrType,
+		Name:    name,
+		Host:    host,
+		Token:   token,
+		Type:    InferType(host, name),
+		Cleanup: cleanup,
 	}
 }
 
@@ -43,7 +46,7 @@ func (a *Arr) Request(method, endpoint string, payload interface{}) (*http.Respo
 	if a.Token == "" || a.Host == "" {
 		return nil, nil
 	}
-	url, err := common.JoinURL(a.Host, endpoint)
+	url, err := request.JoinURL(a.Host, endpoint)
 	if err != nil {
 		return nil, err
 	}
@@ -69,7 +72,7 @@ type Storage struct {
 	mu   sync.RWMutex
 }
 
-func inferType(host, name string) Type {
+func InferType(host, name string) Type {
 	switch {
 	case strings.Contains(host, "sonarr") || strings.Contains(name, "sonarr"):
 		return Sonarr
@@ -84,11 +87,11 @@ func inferType(host, name string) Type {
 	}
 }
 
-func NewStorage(cfg []common.ArrConfig) *Storage {
+func NewStorage() *Storage {
 	arrs := make(map[string]*Arr)
-	for _, a := range cfg {
+	for _, a := range config.GetConfig().Arrs {
 		name := a.Name
-		arrs[name] = NewArr(name, a.Host, a.Token, inferType(a.Host, name))
+		arrs[name] = New(name, a.Host, a.Token, a.Cleanup)
 	}
 	return &Storage{
 		Arrs: arrs,

pkg/arr/content.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"strconv"
 )
 
 func (a *Arr) GetMedia(tvId string) ([]Content, error) {
@@ -13,9 +14,7 @@ func (a *Arr) GetMedia(tvId string) ([]Content, error) {
 		return nil, err
 	}
 	if resp.StatusCode == http.StatusNotFound {
-		// This is Radarr
-		repairLogger.Info().Msg("Radarr detected")
-		a.Type = Radarr
+		// This is likely Radarr
 		return GetMovies(a, tvId)
 	}
 	a.Type = Sonarr
@@ -44,11 +43,34 @@ func (a *Arr) GetMedia(tvId string) ([]Content, error) {
 			Title: d.Title,
 			Id:    d.Id,
 		}
-		files := make([]contentFile, 0)
+
+		type episode struct {
+			Id            int `json:"id"`
+			EpisodeFileID int `json:"episodeFileId"`
+		}
+		resp, err = a.Request(http.MethodGet, fmt.Sprintf("api/v3/episode?seriesId=%d", d.Id), nil)
+		if err != nil {
+			continue
+		}
+		defer resp.Body.Close()
+		var episodes []episode
+		if err = json.NewDecoder(resp.Body).Decode(&episodes); err != nil {
+			continue
+		}
+		episodeFileIDMap := make(map[int]int)
+		for _, e := range episodes {
+			episodeFileIDMap[e.EpisodeFileID] = e.Id
+		}
+		files := make([]ContentFile, 0)
 		for _, file := range seriesFiles {
-			files = append(files, contentFile{
-				Id:   file.Id,
-				Path: file.Path,
+			eId, ok := episodeFileIDMap[file.Id]
+			if !ok {
+				eId = 0
+			}
+			files = append(files, ContentFile{
+				FileId: file.Id,
+				Path:   file.Path,
+				Id:     eId,
 			})
 		}
 		ct.Files = files
@@ -62,6 +84,11 @@ func GetMovies(a *Arr, tvId string) ([]Content, error) {
 	if err != nil {
 		return nil, err
 	}
+	if resp.StatusCode == http.StatusNotFound {
+		// This is likely Lidarr or Readarr
+		return nil, fmt.Errorf("failed to get movies: %s", resp.Status)
+	}
+	a.Type = Radarr
 	defer resp.Body.Close()
 	var movies []Movie
 	if err = json.NewDecoder(resp.Body).Decode(&movies); err != nil {
@@ -73,10 +100,11 @@ func GetMovies(a *Arr, tvId string) ([]Content, error) {
 			Title: movie.Title,
 			Id:    movie.Id,
 		}
-		files := make([]contentFile, 0)
-		files = append(files, contentFile{
-			Id:   movie.MovieFile.Id,
-			Path: movie.MovieFile.Path,
+		files := make([]ContentFile, 0)
+		files = append(files, ContentFile{
+			FileId: movie.MovieFile.Id,
+			Id:     movie.Id,
+			Path:   movie.MovieFile.Path,
 		})
 		ct.Files = files
 		contents = append(contents, ct)
@@ -84,15 +112,76 @@ func GetMovies(a *Arr, tvId string) ([]Content, error) {
 	return contents, nil
 }
 
-func (a *Arr) DeleteFile(id int) error {
+func (a *Arr) search(ids []int) error {
+	var payload interface{}
 	switch a.Type {
 	case Sonarr:
-		_, err := a.Request(http.MethodDelete, fmt.Sprintf("api/v3/episodefile/%d", id), nil)
+		payload = struct {
+			Name       string `json:"name"`
+			EpisodeIds []int  `json:"episodeIds"`
+		}{
+			Name:       "EpisodeSearch",
+			EpisodeIds: ids,
+		}
+	case Radarr:
+		payload = struct {
+			Name     string `json:"name"`
+			MovieIds []int  `json:"movieIds"`
+		}{
+			Name:     "MoviesSearch",
+			MovieIds: ids,
+		}
+	default:
+		return fmt.Errorf("unknown arr type: %s", a.Type)
+	}
+
+	resp, err := a.Request(http.MethodPost, "api/v3/command", payload)
+	if err != nil {
+		return fmt.Errorf("failed to automatic search: %v", err)
+	}
+	if statusOk := strconv.Itoa(resp.StatusCode)[0] == '2'; !statusOk {
+		return fmt.Errorf("failed to automatic search. Status Code: %s", resp.Status)
+	}
+	return nil
+}
+
+func (a *Arr) SearchMissing(files []ContentFile) error {
+
+	ids := make([]int, 0)
+	for _, f := range files {
+		ids = append(ids, f.Id)
+	}
+
+	if len(ids) == 0 {
+		return nil
+	}
+	return a.search(ids)
+}
+
+func (a *Arr) DeleteFiles(files []ContentFile) error {
+	ids := make([]int, 0)
+	for _, f := range files {
+		ids = append(ids, f.FileId)
+	}
+	var payload interface{}
+	switch a.Type {
+	case Sonarr:
+		payload = struct {
+			EpisodeFileIds []int `json:"episodeFileIds"`
+		}{
+			EpisodeFileIds: ids,
+		}
+		_, err := a.Request(http.MethodDelete, "api/v3/episodefile/bulk", payload)
 		if err != nil {
 			return err
 		}
 	case Radarr:
-		_, err := a.Request(http.MethodDelete, fmt.Sprintf("api/v3/moviefile/%d", id), nil)
+		payload = struct {
+			MovieFileIds []int `json:"movieFileIds"`
+		}{
+			MovieFileIds: ids,
+		}
+		_, err := a.Request(http.MethodDelete, "api/v3/moviefile/bulk", payload)
 		if err != nil {
 			return err
 		}

pkg/arr/history.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"net/http"
 	gourl "net/url"
+	"strings"
 )
 
 type HistorySchema struct {
@@ -18,6 +19,37 @@ type HistorySchema struct {
 	} `json:"records"`
 }
 
+type QueueResponseScheme struct {
+	Page          int           `json:"page"`
+	PageSize      int           `json:"pageSize"`
+	SortKey       string        `json:"sortKey"`
+	SortDirection string        `json:"sortDirection"`
+	TotalRecords  int           `json:"totalRecords"`
+	Records       []QueueSchema `json:"records"`
+}
+
+type QueueSchema struct {
+	SeriesId              int    `json:"seriesId"`
+	EpisodeId             int    `json:"episodeId"`
+	SeasonNumber          int    `json:"seasonNumber"`
+	Title                 string `json:"title"`
+	Status                string `json:"status"`
+	TrackedDownloadStatus string `json:"trackedDownloadStatus"`
+	TrackedDownloadState  string `json:"trackedDownloadState"`
+	StatusMessages        []struct {
+		Title    string   `json:"title"`
+		Messages []string `json:"messages"`
+	} `json:"statusMessages"`
+	DownloadId                          string `json:"downloadId"`
+	Protocol                            string `json:"protocol"`
+	DownloadClient                      string `json:"downloadClient"`
+	DownloadClientHasPostImportCategory bool   `json:"downloadClientHasPostImportCategory"`
+	Indexer                             string `json:"indexer"`
+	OutputPath                          string `json:"outputPath"`
+	EpisodeHasFile                      bool   `json:"episodeHasFile"`
+	Id                                  int    `json:"id"`
+}
+
 func (a *Arr) GetHistory(downloadId, eventType string) *HistorySchema {
 	query := gourl.Values{}
 	if downloadId != "" {
@@ -25,7 +57,7 @@ func (a *Arr) GetHistory(downloadId, eventType string) *HistorySchema {
 	}
 	query.Add("eventType", eventType)
 	query.Add("pageSize", "100")
-	url := "history" + "?" + query.Encode()
+	url := "api/v3/history" + "?" + query.Encode()
 	resp, err := a.Request(http.MethodGet, url, nil)
 	if err != nil {
 		return nil
@@ -39,3 +71,98 @@ func (a *Arr) GetHistory(downloadId, eventType string) *HistorySchema {
 	return data
 
 }
+
+func (a *Arr) GetQueue() []QueueSchema {
+	query := gourl.Values{}
+	query.Add("page", "1")
+	query.Add("pageSize", "200")
+	results := make([]QueueSchema, 0)
+	for {
+		url := "api/v3/queue" + "?" + query.Encode()
+		resp, err := a.Request(http.MethodGet, url, nil)
+		if err != nil {
+			break
+		}
+		defer resp.Body.Close()
+		var data QueueResponseScheme
+		if err = json.NewDecoder(resp.Body).Decode(&data); err != nil {
+			break
+		}
+		if len(results) < data.TotalRecords {
+			results = append(results, data.Records...)
+			query.Set("page", string(rune(data.Page+1)))
+		} else {
+			break
+		}
+	}
+	return results
+}
+
+func (a *Arr) CleanupQueue() error {
+	queue := a.GetQueue()
+	type messedUp struct {
+		id        int
+		episodeId int
+		seasonNum int
+	}
+	cleanups := make(map[int][]messedUp)
+	for _, q := range queue {
+		isMessedUp := false
+		if q.Protocol == "torrent" && q.Status == "completed" && q.TrackedDownloadStatus == "warning" && q.TrackedDownloadState == "importPending" {
+			messages := q.StatusMessages
+			if len(messages) > 0 {
+				for _, m := range messages {
+					if strings.Contains(strings.Join(m.Messages, " "), "No files found are eligible for import in") {
+						isMessedUp = true
+						break
+					}
+				}
+			}
+		}
+		if isMessedUp {
+			cleanups[q.SeriesId] = append(cleanups[q.SeriesId], messedUp{
+				id:        q.Id,
+				episodeId: q.EpisodeId,
+				seasonNum: q.SeasonNumber,
+			})
+		}
+	}
+
+	if len(cleanups) == 0 {
+		return nil
+	}
+
+	queueIds := make([]int, 0)
+	episodesIds := make([]int, 0)
+
+	for _, c := range cleanups {
+		// Delete the messed up episodes from queue
+		for _, m := range c {
+			queueIds = append(queueIds, m.id)
+			episodesIds = append(episodesIds, m.episodeId)
+		}
+	}
+
+	// Delete the messed up episodes from queue
+
+	payload := struct {
+		Ids []int `json:"ids"`
+	}{
+		Ids: queueIds,
+	}
+
+	// Blocklist that hash(it's typically not complete, then research the episode)
+
+	query := gourl.Values{}
+	query.Add("removeFromClient", "true")
+	query.Add("blocklist", "true")
+	query.Add("skipRedownload", "false")
+	query.Add("changeCategory", "false")
+	url := "api/v3/queue/bulk" + "?" + query.Encode()
+
+	_, err := a.Request(http.MethodDelete, url, payload)
+	if err != nil {
+		return err
+	}
+	return nil
+}

pkg/arr/refresh.go

@@ -3,7 +3,7 @@ package arr
 import (
 	"cmp"
 	"fmt"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
 	"net/http"
 	"strconv"
 	"strings"
@@ -22,7 +22,7 @@ func (a *Arr) Refresh() error {
 	return fmt.Errorf("failed to refresh monitored downloads for %s", cmp.Or(a.Name, a.Host))
 }
 
-func (a *Arr) MarkAsFailed(infoHash string) error {
+func (a *Arr) Blacklist(infoHash string) error {
 	downloadId := strings.ToUpper(infoHash)
 	history := a.GetHistory(downloadId, "grabbed")
 	if history == nil {
@@ -36,7 +36,7 @@ func (a *Arr) MarkAsFailed(infoHash string) error {
 		}
 	}
 	if torrentId != 0 {
-		url, err := common.JoinURL(a.Host, "history/failed/", strconv.Itoa(torrentId))
+		url, err := request.JoinURL(a.Host, "history/failed/", strconv.Itoa(torrentId))
 		if err != nil {
 			return err
 		}

pkg/arr/repair.go

@@ -1,344 +0,0 @@
-package arr
-
-import (
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strconv"
-	"sync"
-)
-
-var repairLogger *zerolog.Logger
-
-func getLogger() *zerolog.Logger {
-	if repairLogger == nil {
-		logger := common.NewLogger("repair", common.CONFIG.LogLevel, os.Stdout)
-		repairLogger = &logger
-	}
-	return repairLogger
-}
-
-func (a *Arr) SearchMissing(id int) {
-	var payload interface{}
-
-	switch a.Type {
-	case Sonarr:
-		payload = struct {
-			Name     string `json:"name"`
-			SeriesId int    `json:"seriesId"`
-		}{
-			Name:     "SeriesSearch",
-			SeriesId: id,
-		}
-	case Radarr:
-		payload = struct {
-			Name    string `json:"name"`
-			MovieId int    `json:"movieId"`
-		}{
-			Name:    "MoviesSearch",
-			MovieId: id,
-		}
-	default:
-		getLogger().Info().Msgf("Unknown arr type: %s", a.Type)
-		return
-	}
-
-	resp, err := a.Request(http.MethodPost, "api/v3/command", payload)
-	if err != nil {
-		getLogger().Info().Msgf("Failed to search missing: %v", err)
-		return
-	}
-	if statusOk := strconv.Itoa(resp.StatusCode)[0] == '2'; !statusOk {
-		getLogger().Info().Msgf("Failed to search missing: %s", resp.Status)
-		return
-	}
-}
-
-func (a *Arr) Repair(tmdbId string) error {
-
-	getLogger().Info().Msgf("Starting repair for %s", a.Name)
-	media, err := a.GetMedia(tmdbId)
-	if err != nil {
-		getLogger().Info().Msgf("Failed to get %s media: %v", a.Type, err)
-		return err
-	}
-	getLogger().Info().Msgf("Found %d %s media", len(media), a.Type)
-
-	brokenMedia := a.processMedia(media)
-	getLogger().Info().Msgf("Found %d %s broken media files", len(brokenMedia), a.Type)
-
-	// Automatic search for missing files
-	for _, m := range brokenMedia {
-		getLogger().Debug().Msgf("Searching missing for %s", m.Title)
-		a.SearchMissing(m.Id)
-	}
-	getLogger().Info().Msgf("Repair completed for %s", a.Name)
-	return nil
-}
-
-func (a *Arr) processMedia(media []Content) []Content {
-	if len(media) <= 1 {
-		var brokenMedia []Content
-		for _, m := range media {
-			// Check if media is accessible
-			if !a.isMediaAccessible(m) {
-				getLogger().Debug().Msgf("Skipping media check for %s - parent directory not accessible", m.Title)
-				continue
-			}
-			if a.checkMediaFiles(m) {
-				brokenMedia = append(brokenMedia, m)
-			}
-		}
-		return brokenMedia
-	}
-
-	workerCount := runtime.NumCPU() * 4
-	if len(media) < workerCount {
-		workerCount = len(media)
-	}
-
-	jobs := make(chan Content)
-	results := make(chan Content)
-	var brokenMedia []Content
-
-	var wg sync.WaitGroup
-	for i := 0; i < workerCount; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for m := range jobs {
-				// Check if media is accessible
-				// First check if we can access this media's directory
-				if !a.isMediaAccessible(m) {
-					getLogger().Debug().Msgf("Skipping media check for %s - parent directory not accessible", m.Title)
-					continue
-				}
-				if a.checkMediaFilesParallel(m) {
-					results <- m
-				}
-			}
-		}()
-	}
-
-	go func() {
-		for _, m := range media {
-			jobs <- m
-		}
-		close(jobs)
-	}()
-
-	go func() {
-		wg.Wait()
-		close(results)
-	}()
-
-	for m := range results {
-		brokenMedia = append(brokenMedia, m)
-	}
-
-	return brokenMedia
-}
-
-func (a *Arr) checkMediaFilesParallel(m Content) bool {
-	if len(m.Files) <= 1 {
-		return a.checkMediaFiles(m)
-	}
-
-	fileWorkers := runtime.NumCPU() * 2
-	if len(m.Files) < fileWorkers {
-		fileWorkers = len(m.Files)
-	}
-
-	fileJobs := make(chan contentFile)
-	brokenFiles := make(chan bool, len(m.Files))
-
-	var fileWg sync.WaitGroup
-	for i := 0; i < fileWorkers; i++ {
-		fileWg.Add(1)
-		go func() {
-			defer fileWg.Done()
-			for f := range fileJobs {
-				getLogger().Debug().Msgf("Checking file: %s", f.Path)
-				isBroken := false
-
-				if fileIsSymlinked(f.Path) {
-					getLogger().Debug().Msgf("File is symlinked: %s", f.Path)
-					if !fileIsCorrectSymlink(f.Path) {
-						getLogger().Debug().Msgf("File is broken: %s", f.Path)
-						isBroken = true
-						if err := a.DeleteFile(f.Id); err != nil {
-							getLogger().Info().Msgf("Failed to delete file: %s %d: %v", f.Path, f.Id, err)
-						}
-					}
-				} else {
-					getLogger().Debug().Msgf("File is not symlinked: %s", f.Path)
-					if !fileIsReadable(f.Path) {
-						getLogger().Debug().Msgf("File is broken: %s", f.Path)
-						isBroken = true
-						if err := a.DeleteFile(f.Id); err != nil {
-							getLogger().Info().Msgf("Failed to delete file: %s %d: %v", f.Path, f.Id, err)
-						}
-					}
-				}
-				brokenFiles <- isBroken
-			}
-		}()
-	}
-
-	go func() {
-		for _, f := range m.Files {
-			fileJobs <- f
-		}
-		close(fileJobs)
-	}()
-
-	go func() {
-		fileWg.Wait()
-		close(brokenFiles)
-	}()
-
-	isBroken := false
-	for broken := range brokenFiles {
-		if broken {
-			isBroken = true
-		}
-	}
-
-	return isBroken
-}
-
-func (a *Arr) checkMediaFiles(m Content) bool {
-	isBroken := false
-	for _, f := range m.Files {
-		if fileIsSymlinked(f.Path) {
-			if !fileIsCorrectSymlink(f.Path) {
-				isBroken = true
-				if err := a.DeleteFile(f.Id); err != nil {
-					getLogger().Info().Msgf("Failed to delete file: %s %d: %v", f.Path, f.Id, err)
-				}
-			}
-		} else {
-			if !fileIsReadable(f.Path) {
-				isBroken = true
-				if err := a.DeleteFile(f.Id); err != nil {
-					getLogger().Info().Msgf("Failed to delete file: %s %d: %v", f.Path, f.Id, err)
-				}
-			}
-		}
-	}
-	return isBroken
-}
-
-func (a *Arr) isMediaAccessible(m Content) bool {
-	// We're likely to mount the debrid path.
-	// So instead of checking the arr path, we check the original path
-	// This is because the arr path is likely to be a symlink
-	// And we want to check the actual path where the media is stored
-	// This is to avoid false positives
-
-	if len(m.Files) == 0 {
-		return false
-	}
-
-	// Get the first file to check its target location
-	file := m.Files[0].Path
-
-	var targetPath string
-	fileInfo, err := os.Lstat(file)
-	if err != nil {
-		repairLogger.Debug().Msgf("Cannot stat file %s: %v", file, err)
-		return false
-	}
-
-	if fileInfo.Mode()&os.ModeSymlink != 0 {
-		// If it's a symlink, get where it points to
-		target, err := os.Readlink(file)
-		if err != nil {
-			repairLogger.Debug().Msgf("Cannot read symlink %s: %v", file, err)
-			return false
-		}
-
-		// If the symlink target is relative, make it absolute
-		if !filepath.IsAbs(target) {
-			dir := filepath.Dir(file)
-			target = filepath.Join(dir, target)
-		}
-		targetPath = target
-	} else {
-		// If it's a regular file, use its path
-		targetPath = file
-	}
-
-	mediaDir := filepath.Dir(targetPath) // Gets /remote/storage/Movie
-	parentDir := filepath.Dir(mediaDir)  // Gets /remote/storage
-
-	_, err = os.Stat(parentDir)
-	if err != nil {
-		repairLogger.Debug().Msgf("Parent directory of target not accessible for media %s: %s", m.Title, parentDir)
-		return false
-	}
-	return true
-}
-
-func fileIsSymlinked(file string) bool {
-	info, err := os.Lstat(file)
-	if err != nil {
-		return false
-	}
-	return info.Mode()&os.ModeSymlink != 0
-}
-
-func fileIsCorrectSymlink(file string) bool {
-	target, err := os.Readlink(file)
-	if err != nil {
-		return false
-	}
-
-	if !filepath.IsAbs(target) {
-		dir := filepath.Dir(file)
-		target = filepath.Join(dir, target)
-	}
-
-	return fileIsReadable(target)
-}
-
-func fileIsReadable(filePath string) bool {
-	// First check if file exists and is accessible
-	info, err := os.Stat(filePath)
-	if err != nil {
-		return false
-	}
-
-	// Check if it's a regular file
-	if !info.Mode().IsRegular() {
-		return false
-	}
-
-	// Try to read the first 1024 bytes
-	err = checkFileStart(filePath)
-	if err != nil {
-		return false
-	}
-
-	return true
-}
-
-func checkFileStart(filePath string) error {
-	f, err := os.Open(filePath)
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	buffer := make([]byte, 1024)
-	_, err = io.ReadAtLeast(f, buffer, 1024)
-	if err != nil && err != io.EOF {
-		return err
-	}
-
-	return nil
-}

pkg/arr/types.go

@@ -14,16 +14,20 @@ type Movie struct {
 	Id int `json:"id"`
 }
 
-type contentFile struct {
-	Name string `json:"name"`
-	Path string `json:"path"`
-	Id   int    `json:"id"`
+type ContentFile struct {
+	Name       string `json:"name"`
+	Path       string `json:"path"`
+	Id         int    `json:"id"`
+	FileId     int    `json:"fileId"`
+	TargetPath string `json:"targetPath"`
+	IsSymlink  bool   `json:"isSymlink"`
+	IsBroken   bool   `json:"isBroken"`
 }
 
 type Content struct {
 	Title string        `json:"title"`
 	Id    int           `json:"id"`
-	Files []contentFile `json:"files"`
+	Files []ContentFile `json:"files"`
 }
 
 type seriesFile struct {

pkg/debrid/alldebrid.go

@@ -1,263 +0,0 @@
-package debrid
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/structs"
-	"net/http"
-	gourl "net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-)
-
-type AllDebrid struct {
-	BaseDebrid
-}
-
-func (r *AllDebrid) GetMountPath() string {
-	return r.MountPath
-}
-
-func (r *AllDebrid) GetName() string {
-	return r.Name
-}
-
-func (r *AllDebrid) GetLogger() zerolog.Logger {
-	return r.logger
-}
-
-func (r *AllDebrid) IsAvailable(infohashes []string) map[string]bool {
-	// Check if the infohashes are available in the local cache
-	hashes, result := GetLocalCache(infohashes, r.cache)
-
-	if len(hashes) == 0 {
-		// Either all the infohashes are locally cached or none are
-		r.cache.AddMultiple(result)
-		return result
-	}
-
-	// Divide hashes into groups of 100
-	// AllDebrid does not support checking cached infohashes
-	return result
-}
-
-func (r *AllDebrid) SubmitMagnet(torrent *Torrent) (*Torrent, error) {
-	url := fmt.Sprintf("%s/magnet/upload", r.Host)
-	query := gourl.Values{}
-	query.Add("magnets[]", torrent.Magnet.Link)
-	url += "?" + query.Encode()
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	var data structs.AllDebridUploadMagnetResponse
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return nil, err
-	}
-	magnets := data.Data.Magnets
-	if len(magnets) == 0 {
-		return nil, fmt.Errorf("error adding torrent")
-	}
-	magnet := magnets[0]
-	torrentId := strconv.Itoa(magnet.ID)
-	r.logger.Info().Msgf("Torrent: %s added with id: %s", torrent.Name, torrentId)
-	torrent.Id = torrentId
-
-	return torrent, nil
-}
-
-func getAlldebridStatus(statusCode int) string {
-	switch {
-	case statusCode == 4:
-		return "downloaded"
-	case statusCode >= 0 && statusCode <= 3:
-		return "downloading"
-	default:
-		return "error"
-	}
-}
-
-func flattenFiles(files []structs.AllDebridMagnetFile, parentPath string, index *int) []TorrentFile {
-	result := make([]TorrentFile, 0)
-
-	for _, f := range files {
-		currentPath := f.Name
-		if parentPath != "" {
-			currentPath = filepath.Join(parentPath, f.Name)
-		}
-
-		if f.Elements != nil {
-			// This is a folder, recurse into it
-			result = append(result, flattenFiles(f.Elements, currentPath, index)...)
-		} else {
-			// This is a file
-			fileName := filepath.Base(f.Name)
-			if common.RegexMatch(common.SAMPLEMATCH, fileName) {
-				continue
-			}
-			if !common.RegexMatch(common.VIDEOMATCH, fileName) && !common.RegexMatch(common.MUSICMATCH, fileName) {
-				continue
-			}
-
-			*index++
-			file := TorrentFile{
-				Id:   strconv.Itoa(*index),
-				Name: fileName,
-				Size: f.Size,
-				Path: currentPath,
-			}
-			result = append(result, file)
-		}
-	}
-
-	return result
-}
-
-func (r *AllDebrid) GetTorrent(id string) (*Torrent, error) {
-	torrent := &Torrent{}
-	url := fmt.Sprintf("%s/magnet/status?id=%s", r.Host, id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return torrent, err
-	}
-	var res structs.AllDebridTorrentInfoResponse
-	err = json.Unmarshal(resp, &res)
-	if err != nil {
-		r.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
-		return torrent, err
-	}
-	data := res.Data.Magnets
-	status := getAlldebridStatus(data.StatusCode)
-	name := data.Filename
-	torrent.Id = id
-	torrent.Name = name
-	torrent.Status = status
-	torrent.Filename = name
-	torrent.OriginalFilename = name
-	torrent.Folder = name
-	if status == "downloaded" {
-		torrent.Bytes = data.Size
-
-		torrent.Progress = float64((data.Downloaded / data.Size) * 100)
-		torrent.Speed = data.DownloadSpeed
-		torrent.Seeders = data.Seeders
-		index := -1
-		files := flattenFiles(data.Files, "", &index)
-		parentFolder := data.Filename
-		if data.NbLinks == 1 {
-			// All debrid doesn't return the parent folder for single file torrents
-			parentFolder = ""
-		}
-		torrent.OriginalFilename = parentFolder
-		torrent.Files = files
-	}
-	torrent.Debrid = r
-	return torrent, nil
-}
-
-func (r *AllDebrid) CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error) {
-	for {
-		tb, err := r.GetTorrent(torrent.Id)
-
-		torrent = tb
-
-		if err != nil || tb == nil {
-			return tb, err
-		}
-		status := torrent.Status
-		if status == "downloaded" {
-			r.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			if !isSymlink {
-				err = r.GetDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if status == "downloading" {
-			if !r.DownloadUncached {
-				go torrent.Delete()
-				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
-			}
-			// Break out of the loop if the torrent is downloading.
-			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
-			break
-		} else {
-			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
-		}
-
-	}
-	return torrent, nil
-}
-
-func (r *AllDebrid) DeleteTorrent(torrent *Torrent) {
-	url := fmt.Sprintf("%s/magnet/delete?id=%s", r.Host, torrent.Id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	_, err := r.client.MakeRequest(req)
-	if err == nil {
-		r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
-	} else {
-		r.logger.Info().Msgf("Error deleting torrent: %s", err)
-	}
-}
-
-func (r *AllDebrid) GetDownloadLinks(torrent *Torrent) error {
-	downloadLinks := make([]TorrentDownloadLinks, 0)
-	for _, file := range torrent.Files {
-		url := fmt.Sprintf("%s/link/unlock", r.Host)
-		query := gourl.Values{}
-		query.Add("link", file.Link)
-		url += "?" + query.Encode()
-		req, _ := http.NewRequest(http.MethodGet, url, nil)
-		resp, err := r.client.MakeRequest(req)
-		if err != nil {
-			return err
-		}
-		var data structs.AllDebridDownloadLink
-		if err = json.Unmarshal(resp, &data); err != nil {
-			return err
-		}
-		link := data.Data.Link
-
-		dl := TorrentDownloadLinks{
-			Link:         file.Link,
-			Filename:     data.Data.Filename,
-			DownloadLink: link,
-		}
-		downloadLinks = append(downloadLinks, dl)
-	}
-	torrent.DownloadLinks = downloadLinks
-	return nil
-}
-
-func (r *AllDebrid) GetCheckCached() bool {
-	return r.CheckCached
-}
-
-func NewAllDebrid(dc common.DebridConfig, cache *common.Cache) *AllDebrid {
-	rl := common.ParseRateLimit(dc.RateLimit)
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-	}
-	client := common.NewRLHTTPClient(rl, headers)
-	logger := common.NewLogger(dc.Name, common.CONFIG.LogLevel, os.Stdout)
-	return &AllDebrid{
-		BaseDebrid: BaseDebrid{
-			Name:             "alldebrid",
-			Host:             dc.Host,
-			APIKey:           dc.APIKey,
-			DownloadUncached: dc.DownloadUncached,
-			client:           client,
-			cache:            cache,
-			MountPath:        dc.Folder,
-			logger:           logger,
-			CheckCached:      dc.CheckCached,
-		},
-	}
-}

pkg/debrid/alldebrid/alldebrid.go

@@ -0,0 +1,298 @@
+package alldebrid
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+
+	"net/http"
+	gourl "net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+)
+
+type AllDebrid struct {
+	Name             string
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *request.RLHTTPClient
+	cache            *cache.Cache
+	MountPath        string
+	logger           zerolog.Logger
+	CheckCached      bool
+}
+
+func (ad *AllDebrid) GetName() string {
+	return ad.Name
+}
+
+func (ad *AllDebrid) GetLogger() zerolog.Logger {
+	return ad.logger
+}
+
+func (ad *AllDebrid) IsAvailable(infohashes []string) map[string]bool {
+	// Check if the infohashes are available in the local cache
+	hashes, result := torrent.GetLocalCache(infohashes, ad.cache)
+
+	if len(hashes) == 0 {
+		// Either all the infohashes are locally cached or none are
+		ad.cache.AddMultiple(result)
+		return result
+	}
+
+	// Divide hashes into groups of 100
+	// AllDebrid does not support checking cached infohashes
+	return result
+}
+
+func (ad *AllDebrid) SubmitMagnet(torrent *torrent.Torrent) (*torrent.Torrent, error) {
+	url := fmt.Sprintf("%s/magnet/upload", ad.Host)
+	query := gourl.Values{}
+	query.Add("magnets[]", torrent.Magnet.Link)
+	url += "?" + query.Encode()
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := ad.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var data UploadMagnetResponse
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return nil, err
+	}
+	magnets := data.Data.Magnets
+	if len(magnets) == 0 {
+		return nil, fmt.Errorf("error adding torrent")
+	}
+	magnet := magnets[0]
+	torrentId := strconv.Itoa(magnet.ID)
+	torrent.Id = torrentId
+
+	return torrent, nil
+}
+
+func getAlldebridStatus(statusCode int) string {
+	switch {
+	case statusCode == 4:
+		return "downloaded"
+	case statusCode >= 0 && statusCode <= 3:
+		return "downloading"
+	default:
+		return "error"
+	}
+}
+
+func flattenFiles(files []MagnetFile, parentPath string, index *int) []torrent.File {
+	result := make([]torrent.File, 0)
+
+	cfg := config.GetConfig()
+
+	for _, f := range files {
+		currentPath := f.Name
+		if parentPath != "" {
+			currentPath = filepath.Join(parentPath, f.Name)
+		}
+
+		if f.Elements != nil {
+			// This is a folder, recurse into it
+			result = append(result, flattenFiles(f.Elements, currentPath, index)...)
+		} else {
+			// This is a file
+			fileName := filepath.Base(f.Name)
+
+			// Skip sample files
+			if utils.IsSampleFile(fileName) {
+				continue
+			}
+			if !cfg.IsAllowedFile(fileName) {
+				continue
+			}
+
+			if !cfg.IsSizeAllowed(f.Size) {
+				continue
+			}
+
+			*index++
+			file := torrent.File{
+				Id:   strconv.Itoa(*index),
+				Name: fileName,
+				Size: f.Size,
+				Path: currentPath,
+			}
+			result = append(result, file)
+		}
+	}
+
+	return result
+}
+
+func (ad *AllDebrid) GetTorrent(id string) (*torrent.Torrent, error) {
+	t := &torrent.Torrent{}
+	url := fmt.Sprintf("%s/magnet/status?id=%s", ad.Host, id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := ad.client.MakeRequest(req)
+	if err != nil {
+		return t, err
+	}
+	var res TorrentInfoResponse
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		ad.logger.Info().Msgf("Error unmarshalling torrent info: %s", err)
+		return t, err
+	}
+	data := res.Data.Magnets
+	status := getAlldebridStatus(data.StatusCode)
+	name := data.Filename
+	t.Id = id
+	t.Name = name
+	t.Status = status
+	t.Filename = name
+	t.OriginalFilename = name
+	t.Folder = name
+	t.MountPath = ad.MountPath
+	t.Debrid = ad.Name
+	t.DownloadLinks = make(map[string]torrent.DownloadLinks)
+	if status == "downloaded" {
+		t.Bytes = data.Size
+
+		t.Progress = float64((data.Downloaded / data.Size) * 100)
+		t.Speed = data.DownloadSpeed
+		t.Seeders = data.Seeders
+		index := -1
+		files := flattenFiles(data.Files, "", &index)
+		t.Files = files
+	}
+	return t, nil
+}
+
+func (ad *AllDebrid) CheckStatus(torrent *torrent.Torrent, isSymlink bool) (*torrent.Torrent, error) {
+	for {
+		tb, err := ad.GetTorrent(torrent.Id)
+
+		torrent = tb
+
+		if err != nil || tb == nil {
+			return tb, err
+		}
+		status := torrent.Status
+		if status == "downloaded" {
+			ad.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
+			if !isSymlink {
+				err = ad.GetDownloadLinks(torrent)
+				if err != nil {
+					return torrent, err
+				}
+			}
+			break
+		} else if status == "downloading" {
+			if !ad.DownloadUncached {
+				go ad.DeleteTorrent(torrent)
+				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
+			}
+			// Break out of the loop if the torrent is downloading.
+			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
+			break
+		} else {
+			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
+		}
+
+	}
+	return torrent, nil
+}
+
+func (ad *AllDebrid) DeleteTorrent(torrent *torrent.Torrent) {
+	url := fmt.Sprintf("%s/magnet/delete?id=%s", ad.Host, torrent.Id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	_, err := ad.client.MakeRequest(req)
+	if err == nil {
+		ad.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
+	} else {
+		ad.logger.Info().Msgf("Error deleting torrent: %s", err)
+	}
+}
+
+func (ad *AllDebrid) GetDownloadLinks(t *torrent.Torrent) error {
+	downloadLinks := make(map[string]torrent.DownloadLinks)
+	for _, file := range t.Files {
+		url := fmt.Sprintf("%s/link/unlock", ad.Host)
+		query := gourl.Values{}
+		query.Add("link", file.Link)
+		url += "?" + query.Encode()
+		req, _ := http.NewRequest(http.MethodGet, url, nil)
+		resp, err := ad.client.MakeRequest(req)
+		if err != nil {
+			return err
+		}
+		var data DownloadLink
+		if err = json.Unmarshal(resp, &data); err != nil {
+			return err
+		}
+		link := data.Data.Link
+
+		dl := torrent.DownloadLinks{
+			Link:         file.Link,
+			Filename:     data.Data.Filename,
+			DownloadLink: link,
+		}
+		downloadLinks[file.Id] = dl
+	}
+	t.DownloadLinks = downloadLinks
+	return nil
+}
+
+func (ad *AllDebrid) GetDownloadLink(t *torrent.Torrent, file *torrent.File) *torrent.DownloadLinks {
+	url := fmt.Sprintf("%s/link/unlock", ad.Host)
+	query := gourl.Values{}
+	query.Add("link", file.Link)
+	url += "?" + query.Encode()
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := ad.client.MakeRequest(req)
+	if err != nil {
+		return nil
+	}
+	var data DownloadLink
+	if err = json.Unmarshal(resp, &data); err != nil {
+		return nil
+	}
+	link := data.Data.Link
+	return &torrent.DownloadLinks{
+		DownloadLink: link,
+		Link:         file.Link,
+		Filename:     data.Data.Filename,
+	}
+}
+
+func (ad *AllDebrid) GetCheckCached() bool {
+	return ad.CheckCached
+}
+
+func (ad *AllDebrid) GetTorrents() ([]*torrent.Torrent, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func New(dc config.Debrid, cache *cache.Cache) *AllDebrid {
+	rl := request.ParseRateLimit(dc.RateLimit)
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+	}
+	client := request.NewRLHTTPClient(rl, headers)
+	return &AllDebrid{
+		Name:             "alldebrid",
+		Host:             dc.Host,
+		APIKey:           dc.APIKey,
+		DownloadUncached: dc.DownloadUncached,
+		client:           client,
+		cache:            cache,
+		MountPath:        dc.Folder,
+		logger:           logger.NewLogger(dc.Name, config.GetConfig().LogLevel, os.Stdout),
+		CheckCached:      dc.CheckCached,
+	}
+}

pkg/debrid/alldebrid/types.go

@@ -0,0 +1,75 @@
+package alldebrid
+
+type errorResponse struct {
+	Code    string `json:"code"`
+	Message string `json:"message"`
+}
+
+type MagnetFile struct {
+	Name     string       `json:"n"`
+	Size     int64        `json:"s"`
+	Link     string       `json:"l"`
+	Elements []MagnetFile `json:"e"`
+}
+type magnetInfo struct {
+	Id             int          `json:"id"`
+	Filename       string       `json:"filename"`
+	Size           int64        `json:"size"`
+	Hash           string       `json:"hash"`
+	Status         string       `json:"status"`
+	StatusCode     int          `json:"statusCode"`
+	UploadDate     int          `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"`
+	Type           string       `json:"type"`
+	Notified       bool         `json:"notified"`
+	Version        int          `json:"version"`
+	NbLinks        int          `json:"nbLinks"`
+	Files          []MagnetFile `json:"files"`
+}
+
+type TorrentInfoResponse struct {
+	Status string `json:"status"`
+	Data   struct {
+		Magnets magnetInfo `json:"magnets"`
+	} `json:"data"`
+	Error *errorResponse `json:"error"`
+}
+
+type UploadMagnetResponse struct {
+	Status string `json:"status"`
+	Data   struct {
+		Magnets []struct {
+			Magnet           string `json:"magnet"`
+			Hash             string `json:"hash"`
+			Name             string `json:"name"`
+			FilenameOriginal string `json:"filename_original"`
+			Size             int64  `json:"size"`
+			Ready            bool   `json:"ready"`
+			ID               int    `json:"id"`
+		} `json:"magnets"`
+	}
+	Error *errorResponse `json:"error"`
+}
+
+type DownloadLink struct {
+	Status string `json:"status"`
+	Data   struct {
+		Link      string        `json:"link"`
+		Host      string        `json:"host"`
+		Filename  string        `json:"filename"`
+		Streaming []interface{} `json:"streaming"`
+		Paws      bool          `json:"paws"`
+		Filesize  int           `json:"filesize"`
+		Id        string        `json:"id"`
+		Path      []struct {
+			Name string `json:"n"`
+			Size int    `json:"s"`
+		} `json:"path"`
+	} `json:"data"`
+	Error *errorResponse `json:"error"`
+}

pkg/debrid/cache/cache.go

@@ -0,0 +1,360 @@
+package cache
+
+import (
+	"bufio"
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
+	"time"
+
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/engine"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+)
+
+type DownloadLinkCache struct {
+	Link string `json:"download_link"`
+}
+
+type CachedTorrent struct {
+	*torrent.Torrent
+	LastRead      time.Time                    `json:"last_read"`
+	IsComplete    bool                         `json:"is_complete"`
+	DownloadLinks map[string]DownloadLinkCache `json:"download_links"`
+}
+
+var (
+	_logInstance zerolog.Logger
+	once         sync.Once
+)
+
+func getLogger() zerolog.Logger {
+	once.Do(func() {
+		_logInstance = logger.NewLogger("cache", "info", os.Stdout)
+	})
+	return _logInstance
+}
+
+type Cache struct {
+	dir           string
+	client        engine.Service
+	torrents      *sync.Map // key: torrent.Id, value: *CachedTorrent
+	torrentsNames *sync.Map // key: torrent.Name, value: torrent.Id
+	LastUpdated   time.Time `json:"last_updated"`
+}
+
+type Manager struct {
+	caches map[string]*Cache
+}
+
+func NewManager(debridService *engine.Engine) *Manager {
+	cfg := config.GetConfig()
+	cm := &Manager{
+		caches: make(map[string]*Cache),
+	}
+	for _, debrid := range debridService.GetDebrids() {
+		c := New(debrid, cfg.Path)
+		cm.caches[debrid.GetName()] = c
+	}
+	return cm
+}
+
+func (m *Manager) GetCaches() map[string]*Cache {
+	return m.caches
+}
+
+func (m *Manager) GetCache(debridName string) *Cache {
+	return m.caches[debridName]
+}
+
+func New(debridService engine.Service, basePath string) *Cache {
+	return &Cache{
+		dir:           filepath.Join(basePath, "cache", debridService.GetName(), "torrents"),
+		torrents:      &sync.Map{},
+		torrentsNames: &sync.Map{},
+		client:        debridService,
+	}
+}
+
+func (c *Cache) Start() error {
+	_logger := getLogger()
+	_logger.Info().Msg("Starting cache for: " + c.client.GetName())
+	if err := c.Load(); err != nil {
+		return fmt.Errorf("failed to load cache: %v", err)
+	}
+	if err := c.Sync(); err != nil {
+		return fmt.Errorf("failed to sync cache: %v", err)
+	}
+	return nil
+}
+
+func (c *Cache) Load() error {
+	_logger := getLogger()
+
+	if err := os.MkdirAll(c.dir, 0755); err != nil {
+		return fmt.Errorf("failed to create cache directory: %w", err)
+	}
+
+	files, err := os.ReadDir(c.dir)
+	if err != nil {
+		return fmt.Errorf("failed to read cache directory: %w", err)
+	}
+
+	for _, file := range files {
+		if file.IsDir() || filepath.Ext(file.Name()) != ".json" {
+			continue
+		}
+
+		filePath := filepath.Join(c.dir, file.Name())
+		data, err := os.ReadFile(filePath)
+		if err != nil {
+			_logger.Debug().Err(err).Msgf("Failed to read file: %s", filePath)
+			continue
+		}
+
+		var ct CachedTorrent
+		if err := json.Unmarshal(data, &ct); err != nil {
+			_logger.Debug().Err(err).Msgf("Failed to unmarshal file: %s", filePath)
+			continue
+		}
+		if len(ct.Files) > 0 {
+			c.torrents.Store(ct.Torrent.Id, &ct)
+			c.torrentsNames.Store(ct.Torrent.Name, ct.Torrent.Id)
+		}
+	}
+
+	return nil
+}
+
+func (c *Cache) GetTorrent(id string) *CachedTorrent {
+	if value, ok := c.torrents.Load(id); ok {
+		return value.(*CachedTorrent)
+	}
+	return nil
+}
+
+func (c *Cache) GetTorrentByName(name string) *CachedTorrent {
+	if id, ok := c.torrentsNames.Load(name); ok {
+		return c.GetTorrent(id.(string))
+	}
+	return nil
+}
+
+func (c *Cache) SaveTorrent(ct *CachedTorrent) error {
+	data, err := json.MarshalIndent(ct, "", "  ")
+	if err != nil {
+		return fmt.Errorf("failed to marshal torrent: %w", err)
+	}
+
+	fileName := ct.Torrent.Id + ".json"
+	filePath := filepath.Join(c.dir, fileName)
+	tmpFile := filePath + ".tmp"
+
+	f, err := os.Create(tmpFile)
+	if err != nil {
+		return fmt.Errorf("failed to create temp file: %w", err)
+	}
+	defer f.Close()
+
+	w := bufio.NewWriter(f)
+	if _, err := w.Write(data); err != nil {
+		return fmt.Errorf("failed to write data: %w", err)
+	}
+
+	if err := w.Flush(); err != nil {
+		return fmt.Errorf("failed to flush data: %w", err)
+	}
+
+	return os.Rename(tmpFile, filePath)
+}
+
+func (c *Cache) SaveAll() error {
+	const batchSize = 100
+	var wg sync.WaitGroup
+	_logger := getLogger()
+
+	tasks := make(chan *CachedTorrent, batchSize)
+
+	for i := 0; i < runtime.NumCPU(); i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for ct := range tasks {
+				if err := c.SaveTorrent(ct); err != nil {
+					_logger.Error().Err(err).Msg("failed to save torrent")
+				}
+			}
+		}()
+	}
+
+	c.torrents.Range(func(_, value interface{}) bool {
+		tasks <- value.(*CachedTorrent)
+		return true
+	})
+
+	close(tasks)
+	wg.Wait()
+	c.LastUpdated = time.Now()
+	return nil
+}
+
+func (c *Cache) Sync() error {
+	_logger := getLogger()
+	torrents, err := c.client.GetTorrents()
+	if err != nil {
+		return fmt.Errorf("failed to sync torrents: %v", err)
+	}
+
+	workers := runtime.NumCPU() * 200
+	workChan := make(chan *torrent.Torrent, len(torrents))
+	errChan := make(chan error, len(torrents))
+
+	var wg sync.WaitGroup
+
+	for i := 0; i < workers; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for t := range workChan {
+				if err := c.processTorrent(t); err != nil {
+					errChan <- err
+				}
+			}
+		}()
+	}
+
+	for _, t := range torrents {
+		workChan <- t
+	}
+	close(workChan)
+
+	wg.Wait()
+	close(errChan)
+
+	for err := range errChan {
+		_logger.Error().Err(err).Msg("sync error")
+	}
+
+	_logger.Info().Msgf("Synced %d torrents", len(torrents))
+	return nil
+}
+
+func (c *Cache) processTorrent(t *torrent.Torrent) error {
+	if existing, ok := c.torrents.Load(t.Id); ok {
+		ct := existing.(*CachedTorrent)
+		if ct.IsComplete {
+			return nil
+		}
+	}
+	c.AddTorrent(t)
+	return nil
+}
+
+func (c *Cache) AddTorrent(t *torrent.Torrent) {
+	_logger := getLogger()
+
+	if len(t.Files) == 0 {
+		tNew, err := c.client.GetTorrent(t.Id)
+		_logger.Debug().Msgf("Getting torrent files for %s", t.Id)
+		if err != nil {
+			_logger.Debug().Msgf("Failed to get torrent files for %s: %v", t.Id, err)
+			return
+		}
+		t = tNew
+	}
+
+	if len(t.Files) == 0 {
+		_logger.Debug().Msgf("No files found for %s", t.Id)
+		return
+	}
+
+	ct := &CachedTorrent{
+		Torrent:       t,
+		LastRead:      time.Now(),
+		IsComplete:    len(t.Files) > 0,
+		DownloadLinks: make(map[string]DownloadLinkCache),
+	}
+
+	c.torrents.Store(t.Id, ct)
+	c.torrentsNames.Store(t.Name, t.Id)
+
+	go func() {
+		if err := c.SaveTorrent(ct); err != nil {
+			_logger.Debug().Err(err).Msgf("Failed to save torrent %s", t.Id)
+		}
+	}()
+}
+
+func (c *Cache) RefreshTorrent(torrentId string) *CachedTorrent {
+	_logger := getLogger()
+
+	t, err := c.client.GetTorrent(torrentId)
+	if err != nil {
+		_logger.Debug().Msgf("Failed to get torrent files for %s: %v", torrentId, err)
+		return nil
+	}
+	if len(t.Files) == 0 {
+		return nil
+	}
+
+	ct := &CachedTorrent{
+		Torrent:       t,
+		LastRead:      time.Now(),
+		IsComplete:    len(t.Files) > 0,
+		DownloadLinks: make(map[string]DownloadLinkCache),
+	}
+
+	c.torrents.Store(t.Id, ct)
+	c.torrentsNames.Store(t.Name, t.Id)
+
+	go func() {
+		if err := c.SaveTorrent(ct); err != nil {
+			_logger.Debug().Err(err).Msgf("Failed to save torrent %s", t.Id)
+		}
+	}()
+
+	return ct
+}
+
+func (c *Cache) GetFileDownloadLink(t *CachedTorrent, file *torrent.File) (string, error) {
+	_logger := getLogger()
+
+	if linkCache, ok := t.DownloadLinks[file.Id]; ok {
+		return linkCache.Link, nil
+	}
+
+	if file.Link == "" {
+		t = c.RefreshTorrent(t.Id)
+		if t == nil {
+			return "", fmt.Errorf("torrent not found")
+		}
+		file = t.Torrent.GetFile(file.Id)
+	}
+
+	_logger.Debug().Msgf("Getting download link for %s", t.Name)
+	link := c.client.GetDownloadLink(t.Torrent, file)
+	if link == nil {
+		return "", fmt.Errorf("download link not found")
+	}
+
+	t.DownloadLinks[file.Id] = DownloadLinkCache{
+		Link: link.DownloadLink,
+	}
+
+	go func() {
+		if err := c.SaveTorrent(t); err != nil {
+			_logger.Debug().Err(err).Msgf("Failed to save torrent %s", t.Id)
+		}
+	}()
+
+	return link.DownloadLink, nil
+}
+
+func (c *Cache) GetTorrents() *sync.Map {
+	return c.torrents
+}

pkg/debrid/debrid.go

@@ -1,152 +1,54 @@
 package debrid
 
 import (
+	"cmp"
 	"fmt"
-	"github.com/anacrolix/torrent/metainfo"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
 	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"path/filepath"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/alldebrid"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/debrid_link"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/engine"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/realdebrid"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torbox"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
 )
 
-type BaseDebrid struct {
-	Name             string
-	Host             string `json:"host"`
-	APIKey           string
-	DownloadUncached bool
-	client           *common.RLHTTPClient
-	cache            *common.Cache
-	MountPath        string
-	logger           zerolog.Logger
-	CheckCached      bool
-}
-
-type Service interface {
-	SubmitMagnet(torrent *Torrent) (*Torrent, error)
-	CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error)
-	GetDownloadLinks(torrent *Torrent) error
-	DeleteTorrent(torrent *Torrent)
-	IsAvailable(infohashes []string) map[string]bool
-	GetMountPath() string
-	GetCheckCached() bool
-	GetTorrent(id string) (*Torrent, error)
-	GetName() string
-	GetLogger() zerolog.Logger
-}
-
-func NewDebrid(debs []common.DebridConfig, maxCachedSize int) *DebridService {
-	debrids := make([]Service, 0)
+func New() *engine.Engine {
+	cfg := config.GetConfig()
+	maxCachedSize := cmp.Or(cfg.MaxCacheSize, 1000)
+	debrids := make([]engine.Service, 0)
 	// Divide the cache size by the number of debrids
-	maxCacheSize := maxCachedSize / len(debs)
+	maxCacheSize := maxCachedSize / len(cfg.Debrids)
 
-	for _, dc := range debs {
-		d := createDebrid(dc, common.NewCache(maxCacheSize))
+	for _, dc := range cfg.Debrids {
+		d := createDebrid(dc, cache.New(maxCacheSize))
 		logger := d.GetLogger()
 		logger.Info().Msg("Debrid Service started")
 		debrids = append(debrids, d)
 	}
-	d := &DebridService{debrids: debrids, lastUsed: 0}
+	d := &engine.Engine{Debrids: debrids, LastUsed: 0}
 	return d
 }
 
-func createDebrid(dc common.DebridConfig, cache *common.Cache) Service {
+func createDebrid(dc config.Debrid, cache *cache.Cache) engine.Service {
 	switch dc.Name {
 	case "realdebrid":
-		return NewRealDebrid(dc, cache)
+		return realdebrid.New(dc, cache)
 	case "torbox":
-		return NewTorbox(dc, cache)
+		return torbox.New(dc, cache)
 	case "debridlink":
-		return NewDebridLink(dc, cache)
+		return debrid_link.New(dc, cache)
 	case "alldebrid":
-		return NewAllDebrid(dc, cache)
+		return alldebrid.New(dc, cache)
 	default:
-		return NewRealDebrid(dc, cache)
+		return realdebrid.New(dc, cache)
 	}
 }
 
-func GetTorrentInfo(filePath string) (*Torrent, error) {
-	// Open and read the .torrent file
-	if filepath.Ext(filePath) == ".torrent" {
-		return getTorrentInfo(filePath)
-	} else {
-		return torrentFromMagnetFile(filePath)
-	}
-
-}
-
-func torrentFromMagnetFile(filePath string) (*Torrent, error) {
-	magnetLink := common.OpenMagnetFile(filePath)
-	magnet, err := common.GetMagnetInfo(magnetLink)
-	if err != nil {
-		return nil, err
-	}
-	torrent := &Torrent{
-		InfoHash: magnet.InfoHash,
-		Name:     magnet.Name,
-		Size:     magnet.Size,
-		Magnet:   magnet,
-		Filename: filePath,
-	}
-	return torrent, nil
-}
-
-func getTorrentInfo(filePath string) (*Torrent, error) {
-	mi, err := metainfo.LoadFromFile(filePath)
-	if err != nil {
-		return nil, err
-	}
-	hash := mi.HashInfoBytes()
-	infoHash := hash.HexString()
-	info, err := mi.UnmarshalInfo()
-	if err != nil {
-		return nil, err
-	}
-	infoLength := info.Length
-	magnet := &common.Magnet{
-		InfoHash: infoHash,
-		Name:     info.Name,
-		Size:     infoLength,
-		Link:     mi.Magnet(&hash, &info).String(),
-	}
-	torrent := &Torrent{
-		InfoHash: infoHash,
-		Name:     info.Name,
-		Size:     infoLength,
-		Magnet:   magnet,
-		Filename: filePath,
-	}
-	return torrent, nil
-}
-
-func GetLocalCache(infohashes []string, cache *common.Cache) ([]string, map[string]bool) {
-	result := make(map[string]bool)
-	hashes := make([]string, 0)
-
-	if len(infohashes) == 0 {
-		return hashes, result
-	}
-	if len(infohashes) == 1 {
-		if cache.Exists(infohashes[0]) {
-			return hashes, map[string]bool{infohashes[0]: true}
-		}
-		return infohashes, result
-	}
-
-	cachedHashes := cache.GetMultiple(infohashes)
-	for _, h := range infohashes {
-		_, exists := cachedHashes[h]
-		if !exists {
-			hashes = append(hashes, h)
-		} else {
-			result[h] = true
-		}
-	}
-
-	return infohashes, result
-}
-
-func ProcessTorrent(d *DebridService, magnet *common.Magnet, a *arr.Arr, isSymlink bool) (*Torrent, error) {
-	debridTorrent := &Torrent{
+func ProcessTorrent(d *engine.Engine, magnet *utils.Magnet, a *arr.Arr, isSymlink bool) (*torrent.Torrent, error) {
+	debridTorrent := &torrent.Torrent{
 		InfoHash: magnet.InfoHash,
 		Magnet:   magnet,
 		Name:     magnet.Name,
@@ -156,7 +58,7 @@ func ProcessTorrent(d *DebridService, magnet *common.Magnet, a *arr.Arr, isSymli
 
 	errs := make([]error, 0)
 
-	for index, db := range d.debrids {
+	for index, db := range d.Debrids {
 		logger := db.GetLogger()
 		logger.Info().Msgf("Processing debrid: %s", db.GetName())
 
@@ -173,15 +75,14 @@ func ProcessTorrent(d *DebridService, magnet *common.Magnet, a *arr.Arr, isSymli
 
 		dbt, err := db.SubmitMagnet(debridTorrent)
 		if dbt != nil {
-			dbt.Debrid = db
 			dbt.Arr = a
 		}
 		if err != nil || dbt == nil || dbt.Id == "" {
 			errs = append(errs, err)
 			continue
 		}
-		logger.Info().Msgf("Torrent: %s submitted to %s", dbt.Name, db.GetName())
-		d.lastUsed = index
+		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")

pkg/debrid/debrid_link.go

@@ -1,274 +0,0 @@
-package debrid
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/structs"
-	"log"
-	"net/http"
-	"os"
-	"strings"
-)
-
-type DebridLink struct {
-	BaseDebrid
-}
-
-func (r *DebridLink) GetMountPath() string {
-	return r.MountPath
-}
-
-func (r *DebridLink) GetName() string {
-	return r.Name
-}
-
-func (r *DebridLink) GetLogger() zerolog.Logger {
-	return r.logger
-}
-
-func (r *DebridLink) IsAvailable(infohashes []string) map[string]bool {
-	// Check if the infohashes are available in the local cache
-	hashes, result := GetLocalCache(infohashes, r.cache)
-
-	if len(hashes) == 0 {
-		// Either all the infohashes are locally cached or none are
-		r.cache.AddMultiple(result)
-		return result
-	}
-
-	// Divide hashes into groups of 100
-	for i := 0; i < len(hashes); i += 100 {
-		end := i + 100
-		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/seedbox/cached/%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 structs.DebridLinkAvailableResponse
-		err = json.Unmarshal(resp, &data)
-		if err != nil {
-			r.logger.Info().Msgf("Error marshalling availability: %v", err)
-			return result
-		}
-		if data.Value == nil {
-			return result
-		}
-		value := *data.Value
-		for _, h := range hashes[i:end] {
-			_, exists := value[h]
-			if exists {
-				result[h] = true
-			}
-		}
-	}
-	r.cache.AddMultiple(result) // Add the results to the cache
-	return result
-}
-
-func (r *DebridLink) GetTorrent(id string) (*Torrent, error) {
-	torrent := &Torrent{}
-	url := fmt.Sprintf("%s/seedbox/list?ids=%s", r.Host, id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return torrent, err
-	}
-	var res structs.DebridLinkTorrentInfo
-	err = json.Unmarshal(resp, &res)
-	if err != nil {
-		return torrent, err
-	}
-	if res.Success == false {
-		return torrent, fmt.Errorf("error getting torrent")
-	}
-	if res.Value == nil {
-		return torrent, fmt.Errorf("torrent not found")
-	}
-	dt := *res.Value
-
-	if len(dt) == 0 {
-		return torrent, fmt.Errorf("torrent not found")
-	}
-	data := dt[0]
-	status := "downloading"
-	if data.Status == 100 {
-		status = "downloaded"
-	}
-	name := common.RemoveInvalidChars(data.Name)
-	torrent.Id = data.ID
-	torrent.Name = name
-	torrent.Bytes = data.TotalSize
-	torrent.Folder = name
-	torrent.Progress = data.DownloadPercent
-	torrent.Status = status
-	torrent.Speed = data.DownloadSpeed
-	torrent.Seeders = data.PeersConnected
-	torrent.Filename = name
-	torrent.OriginalFilename = name
-	files := make([]TorrentFile, len(data.Files))
-	for i, f := range data.Files {
-		files[i] = TorrentFile{
-			Id:   f.ID,
-			Name: f.Name,
-			Size: f.Size,
-			Path: f.Name,
-		}
-	}
-	torrent.Files = files
-	torrent.Debrid = r
-	return torrent, nil
-}
-
-func (r *DebridLink) SubmitMagnet(torrent *Torrent) (*Torrent, error) {
-	url := fmt.Sprintf("%s/seedbox/add", r.Host)
-	payload := map[string]string{"url": torrent.Magnet.Link}
-	jsonPayload, _ := json.Marshal(payload)
-	req, _ := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonPayload))
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	var res structs.DebridLinkSubmitTorrentInfo
-	err = json.Unmarshal(resp, &res)
-	if err != nil {
-		return nil, err
-	}
-	if res.Success == false || res.Value == nil {
-		return nil, fmt.Errorf("error adding torrent")
-	}
-	data := *res.Value
-	status := "downloading"
-	log.Printf("Torrent: %s added with id: %s", torrent.Name, data.ID)
-	name := common.RemoveInvalidChars(data.Name)
-	torrent.Id = data.ID
-	torrent.Name = name
-	torrent.Bytes = data.TotalSize
-	torrent.Folder = name
-	torrent.Progress = data.DownloadPercent
-	torrent.Status = status
-	torrent.Speed = data.DownloadSpeed
-	torrent.Seeders = data.PeersConnected
-	torrent.Filename = name
-	torrent.OriginalFilename = name
-	files := make([]TorrentFile, len(data.Files))
-	for i, f := range data.Files {
-		files[i] = TorrentFile{
-			Id:   f.ID,
-			Name: f.Name,
-			Size: f.Size,
-			Path: f.Name,
-			Link: f.DownloadURL,
-		}
-	}
-	torrent.Files = files
-	torrent.Debrid = r
-
-	return torrent, nil
-}
-
-func (r *DebridLink) CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error) {
-	for {
-		t, err := r.GetTorrent(torrent.Id)
-		torrent = t
-		if err != nil || torrent == nil {
-			return torrent, err
-		}
-		status := torrent.Status
-		if status == "error" || status == "dead" || status == "magnet_error" {
-			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
-		} else if status == "downloaded" {
-			r.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			if !isSymlink {
-				err = r.GetDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if status == "downloading" {
-			if !r.DownloadUncached {
-				go torrent.Delete()
-				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
-			}
-			// Break out of the loop if the torrent is downloading.
-			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
-			break
-		}
-
-	}
-	return torrent, nil
-}
-
-func (r *DebridLink) DeleteTorrent(torrent *Torrent) {
-	url := fmt.Sprintf("%s/seedbox/%s/remove", r.Host, torrent.Id)
-	req, _ := http.NewRequest(http.MethodDelete, url, nil)
-	_, err := r.client.MakeRequest(req)
-	if err == nil {
-		r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
-	} else {
-		r.logger.Info().Msgf("Error deleting torrent: %s", err)
-	}
-}
-
-func (r *DebridLink) GetDownloadLinks(torrent *Torrent) error {
-	downloadLinks := make([]TorrentDownloadLinks, 0)
-	for _, f := range torrent.Files {
-		dl := TorrentDownloadLinks{
-			Link:     f.Link,
-			Filename: f.Name,
-		}
-		downloadLinks = append(downloadLinks, dl)
-	}
-	torrent.DownloadLinks = downloadLinks
-	return nil
-}
-
-func (r *DebridLink) GetCheckCached() bool {
-	return r.CheckCached
-}
-
-func NewDebridLink(dc common.DebridConfig, cache *common.Cache) *DebridLink {
-	rl := common.ParseRateLimit(dc.RateLimit)
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-		"Content-Type":  "application/json",
-	}
-	client := common.NewRLHTTPClient(rl, headers)
-	logger := common.NewLogger(dc.Name, common.CONFIG.LogLevel, os.Stdout)
-	return &DebridLink{
-		BaseDebrid: BaseDebrid{
-			Name:             "debridlink",
-			Host:             dc.Host,
-			APIKey:           dc.APIKey,
-			DownloadUncached: dc.DownloadUncached,
-			client:           client,
-			cache:            cache,
-			MountPath:        dc.Folder,
-			logger:           logger,
-			CheckCached:      dc.CheckCached,
-		},
-	}
-}

pkg/debrid/debrid_link/debrid_link.go

@@ -0,0 +1,293 @@
+package debrid_link
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+
+	"net/http"
+	"os"
+	"strings"
+)
+
+type DebridLink struct {
+	Name             string
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *request.RLHTTPClient
+	cache            *cache.Cache
+	MountPath        string
+	logger           zerolog.Logger
+	CheckCached      bool
+}
+
+func (dl *DebridLink) GetName() string {
+	return dl.Name
+}
+
+func (dl *DebridLink) GetLogger() zerolog.Logger {
+	return dl.logger
+}
+
+func (dl *DebridLink) IsAvailable(infohashes []string) map[string]bool {
+	// Check if the infohashes are available in the local cache
+	hashes, result := torrent.GetLocalCache(infohashes, dl.cache)
+
+	if len(hashes) == 0 {
+		// Either all the infohashes are locally cached or none are
+		dl.cache.AddMultiple(result)
+		return result
+	}
+
+	// Divide hashes into groups of 100
+	for i := 0; i < len(hashes); i += 100 {
+		end := i + 100
+		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/seedbox/cached/%s", dl.Host, hashStr)
+		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)
+			return result
+		}
+		var data AvailableResponse
+		err = json.Unmarshal(resp, &data)
+		if err != nil {
+			dl.logger.Info().Msgf("Error marshalling availability: %v", err)
+			return result
+		}
+		if data.Value == nil {
+			return result
+		}
+		value := *data.Value
+		for _, h := range hashes[i:end] {
+			_, exists := value[h]
+			if exists {
+				result[h] = true
+			}
+		}
+	}
+	dl.cache.AddMultiple(result) // Add the results to the cache
+	return result
+}
+
+func (dl *DebridLink) GetTorrent(id string) (*torrent.Torrent, error) {
+	t := &torrent.Torrent{}
+	url := fmt.Sprintf("%s/seedbox/list?ids=%s", dl.Host, id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := dl.client.MakeRequest(req)
+	if err != nil {
+		return t, err
+	}
+	var res TorrentInfo
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		return t, err
+	}
+	if res.Success == false {
+		return t, fmt.Errorf("error getting torrent")
+	}
+	if res.Value == nil {
+		return t, fmt.Errorf("torrent not found")
+	}
+	dt := *res.Value
+
+	if len(dt) == 0 {
+		return t, fmt.Errorf("torrent not found")
+	}
+	data := dt[0]
+	status := "downloading"
+	if data.Status == 100 {
+		status = "downloaded"
+	}
+	name := utils.RemoveInvalidChars(data.Name)
+	t.Id = data.ID
+	t.Name = name
+	t.Bytes = data.TotalSize
+	t.Folder = name
+	t.Progress = data.DownloadPercent
+	t.Status = status
+	t.Speed = data.DownloadSpeed
+	t.Seeders = data.PeersConnected
+	t.Filename = name
+	t.OriginalFilename = name
+	files := make([]torrent.File, len(data.Files))
+	cfg := config.GetConfig()
+	for i, f := range data.Files {
+		if !cfg.IsSizeAllowed(f.Size) {
+			continue
+		}
+		files[i] = torrent.File{
+			Id:   f.ID,
+			Name: f.Name,
+			Size: f.Size,
+			Path: f.Name,
+		}
+	}
+	t.Files = files
+	return t, nil
+}
+
+func (dl *DebridLink) SubmitMagnet(t *torrent.Torrent) (*torrent.Torrent, error) {
+	url := fmt.Sprintf("%s/seedbox/add", dl.Host)
+	payload := map[string]string{"url": t.Magnet.Link}
+	jsonPayload, _ := json.Marshal(payload)
+	req, _ := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonPayload))
+	resp, err := dl.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var res SubmitTorrentInfo
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		return nil, err
+	}
+	if res.Success == false || res.Value == nil {
+		return nil, fmt.Errorf("error adding torrent")
+	}
+	data := *res.Value
+	status := "downloading"
+	name := utils.RemoveInvalidChars(data.Name)
+	t.Id = data.ID
+	t.Name = name
+	t.Bytes = data.TotalSize
+	t.Folder = name
+	t.Progress = data.DownloadPercent
+	t.Status = status
+	t.Speed = data.DownloadSpeed
+	t.Seeders = data.PeersConnected
+	t.Filename = name
+	t.OriginalFilename = name
+	t.MountPath = dl.MountPath
+	t.Debrid = dl.Name
+	t.DownloadLinks = make(map[string]torrent.DownloadLinks)
+	files := make([]torrent.File, len(data.Files))
+	for i, f := range data.Files {
+		files[i] = torrent.File{
+			Id:   f.ID,
+			Name: f.Name,
+			Size: f.Size,
+			Path: f.Name,
+			Link: f.DownloadURL,
+		}
+	}
+	t.Files = files
+
+	return t, nil
+}
+
+func (dl *DebridLink) CheckStatus(torrent *torrent.Torrent, isSymlink bool) (*torrent.Torrent, error) {
+	for {
+		t, err := dl.GetTorrent(torrent.Id)
+		torrent = t
+		if err != nil || torrent == nil {
+			return torrent, err
+		}
+		status := torrent.Status
+		if status == "downloaded" {
+			dl.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
+			err = dl.GetDownloadLinks(torrent)
+			if err != nil {
+				return torrent, err
+			}
+			break
+		} else if status == "downloading" {
+			if !dl.DownloadUncached {
+				go dl.DeleteTorrent(torrent)
+				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
+			}
+			// Break out of the loop if the torrent is downloading.
+			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
+			break
+		} else {
+			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
+		}
+
+	}
+	return torrent, nil
+}
+
+func (dl *DebridLink) DeleteTorrent(torrent *torrent.Torrent) {
+	url := fmt.Sprintf("%s/seedbox/%s/remove", dl.Host, torrent.Id)
+	req, _ := http.NewRequest(http.MethodDelete, url, nil)
+	_, err := dl.client.MakeRequest(req)
+	if err == nil {
+		dl.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
+	} else {
+		dl.logger.Info().Msgf("Error deleting torrent: %s", err)
+	}
+}
+
+func (dl *DebridLink) GetDownloadLinks(t *torrent.Torrent) error {
+	downloadLinks := make(map[string]torrent.DownloadLinks)
+	for _, f := range t.Files {
+		dl := torrent.DownloadLinks{
+			Link:     f.Link,
+			Filename: f.Name,
+		}
+		downloadLinks[f.Id] = dl
+	}
+	t.DownloadLinks = downloadLinks
+	return nil
+}
+
+func (dl *DebridLink) GetDownloadLink(t *torrent.Torrent, file *torrent.File) *torrent.DownloadLinks {
+	dlLink, ok := t.DownloadLinks[file.Id]
+	if !ok {
+		return nil
+	}
+	return &dlLink
+}
+
+func (dl *DebridLink) GetCheckCached() bool {
+	return dl.CheckCached
+}
+
+func New(dc config.Debrid, cache *cache.Cache) *DebridLink {
+	rl := request.ParseRateLimit(dc.RateLimit)
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+		"Content-Type":  "application/json",
+	}
+	client := request.NewRLHTTPClient(rl, headers)
+	return &DebridLink{
+		Name:             "debridlink",
+		Host:             dc.Host,
+		APIKey:           dc.APIKey,
+		DownloadUncached: dc.DownloadUncached,
+		client:           client,
+		cache:            cache,
+		MountPath:        dc.Folder,
+		logger:           logger.NewLogger(dc.Name, config.GetConfig().LogLevel, os.Stdout),
+		CheckCached:      dc.CheckCached,
+	}
+}
+
+func (dl *DebridLink) GetTorrents() ([]*torrent.Torrent, error) {
+	return nil, fmt.Errorf("not implemented")
+}

pkg/debrid/debrid_link/types.go

@@ -1,11 +1,11 @@
-package structs
+package debrid_link
 
-type DebridLinkAPIResponse[T any] struct {
+type APIResponse[T any] struct {
 	Success bool `json:"success"`
 	Value   *T   `json:"value"` // Use pointer to allow nil
 }
 
-type DebridLinkAvailableResponse DebridLinkAPIResponse[map[string]map[string]struct {
+type AvailableResponse APIResponse[map[string]map[string]struct {
 	Name       string `json:"name"`
 	HashString string `json:"hashString"`
 	Files      []struct {
@@ -36,10 +36,10 @@ type debridLinkTorrentInfo struct {
 	} `json:"trackers"`
 	Created         int64   `json:"created"`
 	DownloadPercent float64 `json:"downloadPercent"`
-	DownloadSpeed   int     `json:"downloadSpeed"`
-	UploadSpeed     int     `json:"uploadSpeed"`
+	DownloadSpeed   int64   `json:"downloadSpeed"`
+	UploadSpeed     int64   `json:"uploadSpeed"`
 }
 
-type DebridLinkTorrentInfo DebridLinkAPIResponse[[]debridLinkTorrentInfo]
+type TorrentInfo APIResponse[[]debridLinkTorrentInfo]
 
-type DebridLinkSubmitTorrentInfo DebridLinkAPIResponse[debridLinkTorrentInfo]
+type SubmitTorrentInfo APIResponse[debridLinkTorrentInfo]

pkg/debrid/engine.go

@@ -0,0 +1 @@
+package debrid

pkg/debrid/engine/engine.go

@@ -0,0 +1,26 @@
+package engine
+
+type Engine struct {
+	Debrids  []Service
+	LastUsed int
+}
+
+func (d *Engine) Get() Service {
+	if d.LastUsed == 0 {
+		return d.Debrids[0]
+	}
+	return d.Debrids[d.LastUsed]
+}
+
+func (d *Engine) GetByName(name string) Service {
+	for _, deb := range d.Debrids {
+		if deb.GetName() == name {
+			return deb
+		}
+	}
+	return nil
+}
+
+func (d *Engine) GetDebrids() []Service {
+	return d.Debrids
+}

pkg/debrid/engine/service.go

@@ -0,0 +1,20 @@
+package engine
+
+import (
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+)
+
+type Service interface {
+	SubmitMagnet(tr *torrent.Torrent) (*torrent.Torrent, error)
+	CheckStatus(tr *torrent.Torrent, isSymlink bool) (*torrent.Torrent, error)
+	GetDownloadLinks(tr *torrent.Torrent) error
+	GetDownloadLink(tr *torrent.Torrent, file *torrent.File) *torrent.DownloadLinks
+	DeleteTorrent(tr *torrent.Torrent)
+	IsAvailable(infohashes []string) map[string]bool
+	GetCheckCached() bool
+	GetTorrent(id string) (*torrent.Torrent, error)
+	GetTorrents() ([]*torrent.Torrent, error)
+	GetName() string
+	GetLogger() zerolog.Logger
+}

pkg/debrid/realdebrid.go

@@ -1,296 +0,0 @@
-package debrid
-
-import (
-	"encoding/json"
-	"fmt"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/structs"
-	"net/http"
-	gourl "net/url"
-	"os"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-)
-
-type RealDebrid struct {
-	BaseDebrid
-}
-
-func (r *RealDebrid) GetMountPath() string {
-	return r.MountPath
-}
-
-func (r *RealDebrid) GetName() string {
-	return r.Name
-}
-
-func (r *RealDebrid) GetLogger() zerolog.Logger {
-	return r.logger
-}
-
-func GetTorrentFiles(data structs.RealDebridTorrentInfo) []TorrentFile {
-	files := make([]TorrentFile, 0)
-	for _, f := range data.Files {
-		name := filepath.Base(f.Path)
-		if common.RegexMatch(common.SAMPLEMATCH, name) {
-			// Skip sample files
-			continue
-		}
-		if !common.RegexMatch(common.VIDEOMATCH, name) && !common.RegexMatch(common.MUSICMATCH, name) {
-			continue
-		}
-		fileId := f.ID
-		file := TorrentFile{
-			Name: name,
-			Path: name,
-			Size: f.Bytes,
-			Id:   strconv.Itoa(fileId),
-		}
-		files = append(files, file)
-	}
-	return files
-}
-
-func (r *RealDebrid) IsAvailable(infohashes []string) map[string]bool {
-	// Check if the infohashes are available in the local cache
-	hashes, result := GetLocalCache(infohashes, r.cache)
-
-	if len(hashes) == 0 {
-		// Either all the infohashes are locally cached or none are
-		r.cache.AddMultiple(result)
-		return result
-	}
-
-	// 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 structs.RealDebridAvailabilityResponse
-		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
-			}
-		}
-	}
-	r.cache.AddMultiple(result) // Add the results to the cache
-	return result
-}
-
-func (r *RealDebrid) SubmitMagnet(torrent *Torrent) (*Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/addMagnet", r.Host)
-	payload := gourl.Values{
-		"magnet": {torrent.Magnet.Link},
-	}
-	var data structs.RealDebridAddMagnetSchema
-	req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	err = json.Unmarshal(resp, &data)
-	r.logger.Info().Msgf("Torrent: %s added with id: %s", torrent.Name, data.Id)
-	torrent.Id = data.Id
-
-	return torrent, nil
-}
-
-func (r *RealDebrid) GetTorrent(id string) (*Torrent, error) {
-	torrent := &Torrent{}
-	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return torrent, err
-	}
-	var data structs.RealDebridTorrentInfo
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return torrent, err
-	}
-	name := common.RemoveInvalidChars(data.OriginalFilename)
-	torrent.Id = id
-	torrent.Name = name
-	torrent.Bytes = data.Bytes
-	torrent.Folder = name
-	torrent.Progress = data.Progress
-	torrent.Status = data.Status
-	torrent.Speed = data.Speed
-	torrent.Seeders = data.Seeders
-	torrent.Filename = data.Filename
-	torrent.OriginalFilename = data.OriginalFilename
-	torrent.Links = data.Links
-	torrent.Debrid = r
-	files := GetTorrentFiles(data)
-	torrent.Files = files
-	return torrent, nil
-}
-
-func (r *RealDebrid) CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, torrent.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 torrent, err
-		}
-		var data structs.RealDebridTorrentInfo
-		err = json.Unmarshal(resp, &data)
-		status := data.Status
-		name := common.RemoveInvalidChars(data.OriginalFilename)
-		torrent.Name = name // Important because some magnet changes the name
-		torrent.Folder = name
-		torrent.Filename = data.Filename
-		torrent.OriginalFilename = data.OriginalFilename
-		torrent.Bytes = data.Bytes
-		torrent.Progress = data.Progress
-		torrent.Speed = data.Speed
-		torrent.Seeders = data.Seeders
-		torrent.Links = data.Links
-		torrent.Status = status
-		torrent.Debrid = r
-		downloadingStatus := []string{"downloading", "magnet_conversion", "queued", "compressing", "uploading"}
-		if status == "error" || status == "dead" || status == "magnet_error" {
-			return torrent, fmt.Errorf("torrent: %s has error: %s", torrent.Name, status)
-		} else if status == "waiting_files_selection" {
-			files := GetTorrentFiles(data)
-			torrent.Files = files
-			if len(files) == 0 {
-				return torrent, fmt.Errorf("no video files found")
-			}
-			filesId := make([]string, 0)
-			for _, f := range 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, torrent.Id), payload)
-			_, err = r.client.MakeRequest(req)
-			if err != nil {
-				return torrent, err
-			}
-		} else if status == "downloaded" {
-			files := GetTorrentFiles(data)
-			torrent.Files = files
-			r.logger.Info().Msgf("Torrent: %s downloaded to RD", torrent.Name)
-			if !isSymlink {
-				err = r.GetDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if slices.Contains(downloadingStatus, status) {
-			if !r.DownloadUncached {
-				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
-			}
-			// Break out of the loop if the torrent is downloading.
-			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
-			break
-		}
-
-	}
-	return torrent, nil
-}
-
-func (r *RealDebrid) DeleteTorrent(torrent *Torrent) {
-	url := fmt.Sprintf("%s/torrents/delete/%s", r.Host, torrent.Id)
-	req, _ := http.NewRequest(http.MethodDelete, url, nil)
-	_, err := r.client.MakeRequest(req)
-	if err == nil {
-		r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
-	} else {
-		r.logger.Info().Msgf("Error deleting torrent: %s", err)
-	}
-}
-
-func (r *RealDebrid) GetDownloadLinks(torrent *Torrent) error {
-	url := fmt.Sprintf("%s/unrestrict/link/", r.Host)
-	downloadLinks := make([]TorrentDownloadLinks, 0)
-	for _, link := range torrent.Links {
-		if link == "" {
-			continue
-		}
-		payload := gourl.Values{
-			"link": {link},
-		}
-		req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
-		resp, err := r.client.MakeRequest(req)
-		if err != nil {
-			return err
-		}
-		var data structs.RealDebridUnrestrictResponse
-		if err = json.Unmarshal(resp, &data); err != nil {
-			return err
-		}
-		download := TorrentDownloadLinks{
-			Link:         data.Link,
-			Filename:     data.Filename,
-			DownloadLink: data.Download,
-		}
-		downloadLinks = append(downloadLinks, download)
-	}
-	torrent.DownloadLinks = downloadLinks
-	return nil
-}
-
-func (r *RealDebrid) GetCheckCached() bool {
-	return r.CheckCached
-}
-
-func NewRealDebrid(dc common.DebridConfig, cache *common.Cache) *RealDebrid {
-	rl := common.ParseRateLimit(dc.RateLimit)
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-	}
-	client := common.NewRLHTTPClient(rl, headers)
-	logger := common.NewLogger(dc.Name, common.CONFIG.LogLevel, os.Stdout)
-	return &RealDebrid{
-		BaseDebrid: BaseDebrid{
-			Name:             "realdebrid",
-			Host:             dc.Host,
-			APIKey:           dc.APIKey,
-			DownloadUncached: dc.DownloadUncached,
-			client:           client,
-			cache:            cache,
-			MountPath:        dc.Folder,
-			logger:           logger,
-			CheckCached:      dc.CheckCached,
-		},
-	}
-}

pkg/debrid/realdebrid/realdebrid.go

@@ -0,0 +1,400 @@
+package realdebrid
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"net/http"
+	gourl "net/url"
+	"os"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+type RealDebrid struct {
+	Name             string
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *request.RLHTTPClient
+	cache            *cache.Cache
+	MountPath        string
+	logger           zerolog.Logger
+	CheckCached      bool
+}
+
+func (r *RealDebrid) GetName() string {
+	return r.Name
+}
+
+func (r *RealDebrid) GetLogger() zerolog.Logger {
+	return r.logger
+}
+
+// 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(data TorrentInfo, validate bool) []torrent.File {
+	files := make([]torrent.File, 0)
+	cfg := config.GetConfig()
+	idx := 0
+	for _, f := range data.Files {
+
+		name := filepath.Base(f.Path)
+
+		if validate {
+			if utils.RegexMatch(utils.SAMPLEMATCH, name) {
+				// Skip sample files
+				continue
+			}
+			if !cfg.IsAllowedFile(name) {
+				continue
+			}
+			if !cfg.IsSizeAllowed(f.Bytes) {
+				continue
+			}
+		} else {
+			if f.Selected == 0 {
+				continue
+			}
+		}
+
+		fileId := f.ID
+		_link := ""
+		if len(data.Links) > idx {
+			_link = data.Links[idx]
+		}
+		file := torrent.File{
+			Name: name,
+			Path: name,
+			Size: f.Bytes,
+			Id:   strconv.Itoa(fileId),
+			Link: _link,
+		}
+		files = append(files, file)
+		idx++
+	}
+	return files
+}
+
+func (r *RealDebrid) IsAvailable(infohashes []string) map[string]bool {
+	// Check if the infohashes are available in the local cache
+	hashes, result := torrent.GetLocalCache(infohashes, r.cache)
+
+	if len(hashes) == 0 {
+		// Either all the infohashes are locally cached or none are
+		r.cache.AddMultiple(result)
+		return result
+	}
+
+	// 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
+			}
+		}
+	}
+	r.cache.AddMultiple(result) // Add the results to the cache
+	return result
+}
+
+func (r *RealDebrid) SubmitMagnet(t *torrent.Torrent) (*torrent.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
+	}
+	err = json.Unmarshal(resp, &data)
+	t.Id = data.Id
+	t.Debrid = r.Name
+	t.MountPath = r.MountPath
+	return t, nil
+}
+
+func (r *RealDebrid) GetTorrent(id string) (*torrent.Torrent, error) {
+	t := &torrent.Torrent{}
+	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := r.client.MakeRequest(req)
+	if err != nil {
+		return t, err
+	}
+	var data TorrentInfo
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return t, err
+	}
+	name := utils.RemoveInvalidChars(data.OriginalFilename)
+	t.Id = id
+	t.Name = name
+	t.Bytes = data.Bytes
+	t.Folder = name
+	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.DownloadLinks = make(map[string]torrent.DownloadLinks)
+	files := GetTorrentFiles(data, false) // Get selected files
+	t.Files = files
+	return t, nil
+}
+
+func (r *RealDebrid) CheckStatus(t *torrent.Torrent, isSymlink bool) (*torrent.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
+		err = json.Unmarshal(resp, &data)
+		status := data.Status
+		name := utils.RemoveInvalidChars(data.OriginalFilename)
+		t.Name = name // Important because some magnet changes the name
+		t.Folder = name
+		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
+		downloadingStatus := []string{"downloading", "magnet_conversion", "queued", "compressing", "uploading"}
+		if status == "waiting_files_selection" {
+			files := GetTorrentFiles(data, true) // Validate files to be selected
+			t.Files = files
+			if len(files) == 0 {
+				return t, fmt.Errorf("no video files found")
+			}
+			filesId := make([]string, 0)
+			for _, f := range 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" {
+			files := GetTorrentFiles(data, false) // Get selected files
+			t.Files = files
+			r.logger.Info().Msgf("Torrent: %s downloaded to RD", t.Name)
+			if !isSymlink {
+				err = r.GetDownloadLinks(t)
+				if err != nil {
+					return t, err
+				}
+			}
+			break
+		} else if slices.Contains(downloadingStatus, status) {
+			if !r.DownloadUncached {
+				go r.DeleteTorrent(t)
+				return t, fmt.Errorf("torrent: %s not cached", t.Name)
+			}
+			// Break out of the loop if the torrent is downloading.
+			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
+			break
+		} else {
+			return t, fmt.Errorf("torrent: %s has error: %s", t.Name, status)
+		}
+
+	}
+	return t, nil
+}
+
+func (r *RealDebrid) DeleteTorrent(torrent *torrent.Torrent) {
+	url := fmt.Sprintf("%s/torrents/delete/%s", r.Host, torrent.Id)
+	req, _ := http.NewRequest(http.MethodDelete, url, nil)
+	_, err := r.client.MakeRequest(req)
+	if err == nil {
+		r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
+	} else {
+		r.logger.Info().Msgf("Error deleting torrent: %s", err)
+	}
+}
+
+func (r *RealDebrid) GetDownloadLinks(t *torrent.Torrent) error {
+	url := fmt.Sprintf("%s/unrestrict/link/", r.Host)
+	downloadLinks := make(map[string]torrent.DownloadLinks)
+	for _, f := range t.Files {
+		dlLink := t.DownloadLinks[f.Id]
+		if f.Link == "" || dlLink.DownloadLink != "" {
+			continue
+		}
+		payload := gourl.Values{
+			"link": {f.Link},
+		}
+		req, _ := http.NewRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
+		resp, err := r.client.MakeRequest(req)
+		if err != nil {
+			return err
+		}
+		var data UnrestrictResponse
+		if err = json.Unmarshal(resp, &data); err != nil {
+			return err
+		}
+		download := torrent.DownloadLinks{
+			Link:         data.Link,
+			Filename:     data.Filename,
+			DownloadLink: data.Download,
+		}
+		downloadLinks[f.Id] = download
+	}
+	t.DownloadLinks = downloadLinks
+	return nil
+}
+
+func (r *RealDebrid) GetDownloadLink(t *torrent.Torrent, file *torrent.File) *torrent.DownloadLinks {
+	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.client.MakeRequest(req)
+	if err != nil {
+		return nil
+	}
+	var data UnrestrictResponse
+	if err = json.Unmarshal(resp, &data); err != nil {
+		return nil
+	}
+	return &torrent.DownloadLinks{
+		Link:         data.Link,
+		Filename:     data.Filename,
+		DownloadLink: data.Download,
+	}
+}
+
+func (r *RealDebrid) GetCheckCached() bool {
+	return r.CheckCached
+}
+
+func (r *RealDebrid) getTorrents(offset int, limit int) ([]*torrent.Torrent, error) {
+	url := fmt.Sprintf("%s/torrents?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.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var data []TorrentsResponse
+	if err = json.Unmarshal(resp, &data); err != nil {
+		return nil, err
+	}
+	torrents := make([]*torrent.Torrent, 0)
+	for _, t := range data {
+
+		torrents = append(torrents, &torrent.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,
+		})
+	}
+	return torrents, nil
+}
+
+func (r *RealDebrid) GetTorrents() ([]*torrent.Torrent, error) {
+	torrents := make([]*torrent.Torrent, 0)
+	offset := 0
+	limit := 5000
+	for {
+		ts, err := r.getTorrents(offset, limit)
+		if err != nil {
+			break
+		}
+		if len(ts) == 0 {
+			break
+		}
+		torrents = append(torrents, ts...)
+		offset = len(torrents)
+	}
+	return torrents, nil
+
+}
+
+func New(dc config.Debrid, cache *cache.Cache) *RealDebrid {
+	rl := request.ParseRateLimit(dc.RateLimit)
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+	}
+	client := request.NewRLHTTPClient(rl, headers)
+	return &RealDebrid{
+		Name:             "realdebrid",
+		Host:             dc.Host,
+		APIKey:           dc.APIKey,
+		DownloadUncached: dc.DownloadUncached,
+		client:           client,
+		cache:            cache,
+		MountPath:        dc.Folder,
+		logger:           logger.NewLogger(dc.Name, config.GetConfig().LogLevel, os.Stdout),
+		CheckCached:      dc.CheckCached,
+	}
+}

pkg/debrid/realdebrid/types.go

@@ -1,13 +1,14 @@
-package structs
+package realdebrid
 
 import (
 	"encoding/json"
 	"fmt"
+	"time"
 )
 
-type RealDebridAvailabilityResponse map[string]Hoster
+type AvailabilityResponse map[string]Hoster
 
-func (r *RealDebridAvailabilityResponse) UnmarshalJSON(data []byte) error {
+func (r *AvailabilityResponse) UnmarshalJSON(data []byte) error {
 	// First, try to unmarshal as an object
 	var objectData map[string]Hoster
 	err := json.Unmarshal(data, &objectData)
@@ -64,12 +65,12 @@ type FileVariant struct {
 	Filesize int    `json:"filesize"`
 }
 
-type RealDebridAddMagnetSchema struct {
+type AddMagnetSchema struct {
 	Id  string `json:"id"`
 	Uri string `json:"uri"`
 }
 
-type RealDebridTorrentInfo struct {
+type TorrentInfo struct {
 	ID               string  `json:"id"`
 	Filename         string  `json:"filename"`
 	OriginalFilename string  `json:"original_filename"`
@@ -89,11 +90,11 @@ type RealDebridTorrentInfo struct {
 	} `json:"files"`
 	Links   []string `json:"links"`
 	Ended   string   `json:"ended,omitempty"`
-	Speed   int      `json:"speed,omitempty"`
+	Speed   int64    `json:"speed,omitempty"`
 	Seeders int      `json:"seeders,omitempty"`
 }
 
-type RealDebridUnrestrictResponse struct {
+type UnrestrictResponse struct {
 	Id         string `json:"id"`
 	Filename   string `json:"filename"`
 	MimeType   string `json:"mimeType"`
@@ -105,3 +106,17 @@ type RealDebridUnrestrictResponse struct {
 	Download   string `json:"download"`
 	Streamable int    `json:"streamable"`
 }
+
+type TorrentsResponse struct {
+	Id       string    `json:"id"`
+	Filename string    `json:"filename"`
+	Hash     string    `json:"hash"`
+	Bytes    int64     `json:"bytes"`
+	Host     string    `json:"host"`
+	Split    int64     `json:"split"`
+	Progress float64   `json:"progress"`
+	Status   string    `json:"status"`
+	Added    time.Time `json:"added"`
+	Links    []string  `json:"links"`
+	Ended    time.Time `json:"ended"`
+}

pkg/debrid/service.go

@@ -1,22 +0,0 @@
-package debrid
-
-type DebridService struct {
-	debrids  []Service
-	lastUsed int
-}
-
-func (d *DebridService) Get() Service {
-	if d.lastUsed == 0 {
-		return d.debrids[0]
-	}
-	return d.debrids[d.lastUsed]
-}
-
-func (d *DebridService) GetByName(name string) Service {
-	for _, deb := range d.debrids {
-		if deb.GetName() == name {
-			return deb
-		}
-	}
-	return nil
-}

pkg/debrid/structs/alldebrid.go

@@ -1,75 +0,0 @@
-package structs
-
-type errorResponse struct {
-	Code    string `json:"code"`
-	Message string `json:"message"`
-}
-
-type AllDebridMagnetFile struct {
-	Name     string                `json:"n"`
-	Size     int64                 `json:"s"`
-	Link     string                `json:"l"`
-	Elements []AllDebridMagnetFile `json:"e"`
-}
-type magnetInfo struct {
-	Id             int                   `json:"id"`
-	Filename       string                `json:"filename"`
-	Size           int64                 `json:"size"`
-	Hash           string                `json:"hash"`
-	Status         string                `json:"status"`
-	StatusCode     int                   `json:"statusCode"`
-	UploadDate     int                   `json:"uploadDate"`
-	Downloaded     int64                 `json:"downloaded"`
-	Uploaded       int64                 `json:"uploaded"`
-	DownloadSpeed  int                   `json:"downloadSpeed"`
-	UploadSpeed    int                   `json:"uploadSpeed"`
-	Seeders        int                   `json:"seeders"`
-	CompletionDate int                   `json:"completionDate"`
-	Type           string                `json:"type"`
-	Notified       bool                  `json:"notified"`
-	Version        int                   `json:"version"`
-	NbLinks        int                   `json:"nbLinks"`
-	Files          []AllDebridMagnetFile `json:"files"`
-}
-
-type AllDebridTorrentInfoResponse struct {
-	Status string `json:"status"`
-	Data   struct {
-		Magnets magnetInfo `json:"magnets"`
-	} `json:"data"`
-	Error *errorResponse `json:"error"`
-}
-
-type AllDebridUploadMagnetResponse struct {
-	Status string `json:"status"`
-	Data   struct {
-		Magnets []struct {
-			Magnet           string `json:"magnet"`
-			Hash             string `json:"hash"`
-			Name             string `json:"name"`
-			FilenameOriginal string `json:"filename_original"`
-			Size             int64  `json:"size"`
-			Ready            bool   `json:"ready"`
-			ID               int    `json:"id"`
-		} `json:"magnets"`
-	}
-	Error *errorResponse `json:"error"`
-}
-
-type AllDebridDownloadLink struct {
-	Status string `json:"status"`
-	Data   struct {
-		Link      string        `json:"link"`
-		Host      string        `json:"host"`
-		Filename  string        `json:"filename"`
-		Streaming []interface{} `json:"streaming"`
-		Paws      bool          `json:"paws"`
-		Filesize  int           `json:"filesize"`
-		Id        string        `json:"id"`
-		Path      []struct {
-			Name string `json:"n"`
-			Size int    `json:"s"`
-		} `json:"path"`
-	} `json:"data"`
-	Error *errorResponse `json:"error"`
-}

pkg/debrid/torbox.go

@@ -1,306 +0,0 @@
-package debrid
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/structs"
-	"log"
-	"mime/multipart"
-	"net/http"
-	gourl "net/url"
-	"os"
-	"path"
-	"path/filepath"
-	"slices"
-	"strconv"
-	"strings"
-)
-
-type Torbox struct {
-	BaseDebrid
-}
-
-func (r *Torbox) GetMountPath() string {
-	return r.MountPath
-}
-
-func (r *Torbox) GetName() string {
-	return r.Name
-}
-
-func (r *Torbox) GetLogger() zerolog.Logger {
-	return r.logger
-}
-
-func (r *Torbox) IsAvailable(infohashes []string) map[string]bool {
-	// Check if the infohashes are available in the local cache
-	hashes, result := GetLocalCache(infohashes, r.cache)
-
-	if len(hashes) == 0 {
-		// Either all the infohashes are locally cached or none are
-		r.cache.AddMultiple(result)
-		return result
-	}
-
-	// Divide hashes into groups of 100
-	for i := 0; i < len(hashes); i += 100 {
-		end := i + 100
-		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/api/torrents/checkcached?hash=%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 res structs.TorBoxAvailableResponse
-		err = json.Unmarshal(resp, &res)
-		if err != nil {
-			r.logger.Info().Msgf("Error marshalling availability: %v", err)
-			return result
-		}
-		if res.Data == nil {
-			return result
-		}
-
-		for h, cache := range *res.Data {
-			if cache.Size > 0 {
-				result[strings.ToUpper(h)] = true
-			}
-		}
-	}
-	r.cache.AddMultiple(result) // Add the results to the cache
-	return result
-}
-
-func (r *Torbox) SubmitMagnet(torrent *Torrent) (*Torrent, error) {
-	url := fmt.Sprintf("%s/api/torrents/createtorrent", r.Host)
-	payload := &bytes.Buffer{}
-	writer := multipart.NewWriter(payload)
-	_ = writer.WriteField("magnet", torrent.Magnet.Link)
-	err := writer.Close()
-	if err != nil {
-		return nil, err
-	}
-	req, _ := http.NewRequest(http.MethodPost, url, payload)
-	req.Header.Set("Content-Type", writer.FormDataContentType())
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return nil, err
-	}
-	var data structs.TorBoxAddMagnetResponse
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return nil, err
-	}
-	if data.Data == nil {
-		return nil, fmt.Errorf("error adding torrent")
-	}
-	dt := *data.Data
-	torrentId := strconv.Itoa(dt.Id)
-	log.Printf("Torrent: %s added with id: %s", torrent.Name, torrentId)
-	torrent.Id = torrentId
-
-	return torrent, nil
-}
-
-func getTorboxStatus(status string, finished bool) string {
-	if finished {
-		return "downloaded"
-	}
-	downloading := []string{"completed", "cached", "paused", "downloading", "uploading",
-		"checkingResumeData", "metaDL", "pausedUP", "queuedUP", "checkingUP",
-		"forcedUP", "allocating", "downloading", "metaDL", "pausedDL",
-		"queuedDL", "checkingDL", "forcedDL", "checkingResumeData", "moving"}
-	switch {
-	case slices.Contains(downloading, status):
-		return "downloading"
-	default:
-		return "error"
-	}
-}
-
-func (r *Torbox) GetTorrent(id string) (*Torrent, error) {
-	torrent := &Torrent{}
-	url := fmt.Sprintf("%s/api/torrents/mylist/?id=%s", r.Host, id)
-	req, _ := http.NewRequest(http.MethodGet, url, nil)
-	resp, err := r.client.MakeRequest(req)
-	if err != nil {
-		return torrent, err
-	}
-	var res structs.TorboxInfoResponse
-	err = json.Unmarshal(resp, &res)
-	if err != nil {
-		return torrent, err
-	}
-	data := res.Data
-	name := data.Name
-	torrent.Id = id
-	torrent.Name = name
-	torrent.Bytes = data.Size
-	torrent.Folder = name
-	torrent.Progress = data.Progress * 100
-	torrent.Status = getTorboxStatus(data.DownloadState, data.DownloadFinished)
-	torrent.Speed = data.DownloadSpeed
-	torrent.Seeders = data.Seeds
-	torrent.Filename = name
-	torrent.OriginalFilename = name
-	files := make([]TorrentFile, 0)
-	for _, f := range data.Files {
-		fileName := filepath.Base(f.Name)
-		if common.RegexMatch(common.SAMPLEMATCH, fileName) {
-			// Skip sample files
-			continue
-		}
-		if !common.RegexMatch(common.VIDEOMATCH, fileName) && !common.RegexMatch(common.MUSICMATCH, fileName) {
-			continue
-		}
-		file := TorrentFile{
-			Id:   strconv.Itoa(f.Id),
-			Name: fileName,
-			Size: f.Size,
-			Path: fileName,
-		}
-		files = append(files, file)
-	}
-	var cleanPath string
-	if len(files) > 0 {
-		cleanPath = path.Clean(data.Files[0].Name)
-	} else {
-		cleanPath = path.Clean(data.Name)
-	}
-
-	torrent.OriginalFilename = strings.Split(cleanPath, "/")[0]
-	torrent.Files = files
-	torrent.Debrid = r
-	return torrent, nil
-}
-
-func (r *Torbox) CheckStatus(torrent *Torrent, isSymlink bool) (*Torrent, error) {
-	for {
-		tb, err := r.GetTorrent(torrent.Id)
-
-		torrent = tb
-
-		if err != nil || tb == nil {
-			return tb, err
-		}
-		status := torrent.Status
-		if status == "error" || status == "dead" || status == "magnet_error" {
-			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
-		} else if status == "downloaded" {
-			r.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
-			if !isSymlink {
-				err = r.GetDownloadLinks(torrent)
-				if err != nil {
-					return torrent, err
-				}
-			}
-			break
-		} else if status == "downloading" {
-			if !r.DownloadUncached {
-				go torrent.Delete()
-				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
-			}
-			// Break out of the loop if the torrent is downloading.
-			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
-			break
-		}
-
-	}
-	return torrent, nil
-}
-
-func (r *Torbox) DeleteTorrent(torrent *Torrent) {
-	url := fmt.Sprintf("%s/api/torrents/controltorrent/%s", r.Host, torrent.Id)
-	payload := map[string]string{"torrent_id": torrent.Id, "action": "Delete"}
-	jsonPayload, _ := json.Marshal(payload)
-	req, _ := http.NewRequest(http.MethodDelete, url, bytes.NewBuffer(jsonPayload))
-	_, err := r.client.MakeRequest(req)
-	if err == nil {
-		r.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
-	} else {
-		r.logger.Info().Msgf("Error deleting torrent: %s", err)
-	}
-}
-
-func (r *Torbox) GetDownloadLinks(torrent *Torrent) error {
-	downloadLinks := make([]TorrentDownloadLinks, 0)
-	for _, file := range torrent.Files {
-		url := fmt.Sprintf("%s/api/torrents/requestdl/", r.Host)
-		query := gourl.Values{}
-		query.Add("torrent_id", torrent.Id)
-		query.Add("token", r.APIKey)
-		query.Add("file_id", file.Id)
-		url += "?" + query.Encode()
-		req, _ := http.NewRequest(http.MethodGet, url, nil)
-		resp, err := r.client.MakeRequest(req)
-		if err != nil {
-			return err
-		}
-		var data structs.TorBoxDownloadLinksResponse
-		if err = json.Unmarshal(resp, &data); err != nil {
-			return err
-		}
-		if data.Data == nil {
-			return fmt.Errorf("error getting download links")
-		}
-		idx := 0
-		link := *data.Data
-
-		dl := TorrentDownloadLinks{
-			Link:         link,
-			Filename:     torrent.Files[idx].Name,
-			DownloadLink: link,
-		}
-		downloadLinks = append(downloadLinks, dl)
-	}
-	torrent.DownloadLinks = downloadLinks
-	return nil
-}
-
-func (r *Torbox) GetCheckCached() bool {
-	return r.CheckCached
-}
-
-func NewTorbox(dc common.DebridConfig, cache *common.Cache) *Torbox {
-	rl := common.ParseRateLimit(dc.RateLimit)
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-	}
-	client := common.NewRLHTTPClient(rl, headers)
-	logger := common.NewLogger(dc.Name, common.CONFIG.LogLevel, os.Stdout)
-	return &Torbox{
-		BaseDebrid: BaseDebrid{
-			Name:             "torbox",
-			Host:             dc.Host,
-			APIKey:           dc.APIKey,
-			DownloadUncached: dc.DownloadUncached,
-			client:           client,
-			cache:            cache,
-			MountPath:        dc.Folder,
-			logger:           logger,
-			CheckCached:      dc.CheckCached,
-		},
-	}
-}

pkg/debrid/torbox/torbox.go

@@ -0,0 +1,351 @@
+package torbox
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+
+	"mime/multipart"
+	"net/http"
+	gourl "net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+type Torbox struct {
+	Name             string
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *request.RLHTTPClient
+	cache            *cache.Cache
+	MountPath        string
+	logger           zerolog.Logger
+	CheckCached      bool
+}
+
+func (tb *Torbox) GetName() string {
+	return tb.Name
+}
+
+func (tb *Torbox) GetLogger() zerolog.Logger {
+	return tb.logger
+}
+
+func (tb *Torbox) IsAvailable(infohashes []string) map[string]bool {
+	// Check if the infohashes are available in the local cache
+	hashes, result := torrent.GetLocalCache(infohashes, tb.cache)
+
+	if len(hashes) == 0 {
+		// Either all the infohashes are locally cached or none are
+		tb.cache.AddMultiple(result)
+		return result
+	}
+
+	// Divide hashes into groups of 100
+	for i := 0; i < len(hashes); i += 100 {
+		end := i + 100
+		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/api/torrents/checkcached?hash=%s", tb.Host, hashStr)
+		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)
+			return result
+		}
+		var res AvailableResponse
+		err = json.Unmarshal(resp, &res)
+		if err != nil {
+			tb.logger.Info().Msgf("Error marshalling availability: %v", err)
+			return result
+		}
+		if res.Data == nil {
+			return result
+		}
+
+		for h, cache := range *res.Data {
+			if cache.Size > 0 {
+				result[strings.ToUpper(h)] = true
+			}
+		}
+	}
+	tb.cache.AddMultiple(result) // Add the results to the cache
+	return result
+}
+
+func (tb *Torbox) SubmitMagnet(torrent *torrent.Torrent) (*torrent.Torrent, error) {
+	url := fmt.Sprintf("%s/api/torrents/createtorrent", tb.Host)
+	payload := &bytes.Buffer{}
+	writer := multipart.NewWriter(payload)
+	_ = writer.WriteField("magnet", torrent.Magnet.Link)
+	err := writer.Close()
+	if err != nil {
+		return nil, err
+	}
+	req, _ := http.NewRequest(http.MethodPost, url, payload)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	resp, err := tb.client.MakeRequest(req)
+	if err != nil {
+		return nil, err
+	}
+	var data AddMagnetResponse
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return nil, err
+	}
+	if data.Data == nil {
+		return nil, fmt.Errorf("error adding torrent")
+	}
+	dt := *data.Data
+	torrentId := strconv.Itoa(dt.Id)
+	torrent.Id = torrentId
+	torrent.MountPath = tb.MountPath
+	torrent.Debrid = tb.Name
+
+	return torrent, nil
+}
+
+func getTorboxStatus(status string, finished bool) string {
+	if finished {
+		return "downloaded"
+	}
+	downloading := []string{"completed", "cached", "paused", "downloading", "uploading",
+		"checkingResumeData", "metaDL", "pausedUP", "queuedUP", "checkingUP",
+		"forcedUP", "allocating", "downloading", "metaDL", "pausedDL",
+		"queuedDL", "checkingDL", "forcedDL", "checkingResumeData", "moving"}
+	switch {
+	case slices.Contains(downloading, status):
+		return "downloading"
+	default:
+		return "error"
+	}
+}
+
+func (tb *Torbox) GetTorrent(id string) (*torrent.Torrent, error) {
+	t := &torrent.Torrent{}
+	url := fmt.Sprintf("%s/api/torrents/mylist/?id=%s", tb.Host, id)
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := tb.client.MakeRequest(req)
+	if err != nil {
+		return t, err
+	}
+	var res InfoResponse
+	err = json.Unmarshal(resp, &res)
+	if err != nil {
+		return t, err
+	}
+	data := res.Data
+	name := data.Name
+	t.Id = id
+	t.Name = name
+	t.Bytes = data.Size
+	t.Folder = name
+	t.Progress = data.Progress * 100
+	t.Status = getTorboxStatus(data.DownloadState, data.DownloadFinished)
+	t.Speed = data.DownloadSpeed
+	t.Seeders = data.Seeds
+	t.Filename = name
+	t.OriginalFilename = name
+	t.MountPath = tb.MountPath
+	t.Debrid = tb.Name
+	t.DownloadLinks = make(map[string]torrent.DownloadLinks)
+	files := make([]torrent.File, 0)
+	cfg := config.GetConfig()
+	for _, f := range data.Files {
+		fileName := filepath.Base(f.Name)
+		if utils.IsSampleFile(fileName) {
+			// Skip sample files
+			continue
+		}
+		if !cfg.IsAllowedFile(fileName) {
+			continue
+		}
+
+		if !cfg.IsSizeAllowed(f.Size) {
+			continue
+		}
+		file := torrent.File{
+			Id:   strconv.Itoa(f.Id),
+			Name: fileName,
+			Size: f.Size,
+			Path: fileName,
+		}
+		files = append(files, file)
+	}
+	var cleanPath string
+	if len(files) > 0 {
+		cleanPath = path.Clean(data.Files[0].Name)
+	} else {
+		cleanPath = path.Clean(data.Name)
+	}
+
+	t.OriginalFilename = strings.Split(cleanPath, "/")[0]
+	t.Files = files
+	//t.Debrid = tb
+	return t, nil
+}
+
+func (tb *Torbox) CheckStatus(torrent *torrent.Torrent, isSymlink bool) (*torrent.Torrent, error) {
+	for {
+		t, err := tb.GetTorrent(torrent.Id)
+
+		torrent = t
+
+		if err != nil || t == nil {
+			return t, err
+		}
+		status := torrent.Status
+		if status == "downloaded" {
+			tb.logger.Info().Msgf("Torrent: %s downloaded", torrent.Name)
+			if !isSymlink {
+				err = tb.GetDownloadLinks(torrent)
+				if err != nil {
+					return torrent, err
+				}
+			}
+			break
+		} else if status == "downloading" {
+			if !tb.DownloadUncached {
+				go tb.DeleteTorrent(torrent)
+				return torrent, fmt.Errorf("torrent: %s not cached", torrent.Name)
+			}
+			// Break out of the loop if the torrent is downloading.
+			// This is necessary to prevent infinite loop since we moved to sync downloading and async processing
+			break
+		} else {
+			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
+		}
+
+	}
+	return torrent, nil
+}
+
+func (tb *Torbox) DeleteTorrent(torrent *torrent.Torrent) {
+	url := fmt.Sprintf("%s/api/torrents/controltorrent/%s", tb.Host, torrent.Id)
+	payload := map[string]string{"torrent_id": torrent.Id, "action": "Delete"}
+	jsonPayload, _ := json.Marshal(payload)
+	req, _ := http.NewRequest(http.MethodDelete, url, bytes.NewBuffer(jsonPayload))
+	_, err := tb.client.MakeRequest(req)
+	if err == nil {
+		tb.logger.Info().Msgf("Torrent: %s deleted", torrent.Name)
+	} else {
+		tb.logger.Info().Msgf("Error deleting torrent: %s", err)
+	}
+}
+
+func (tb *Torbox) GetDownloadLinks(t *torrent.Torrent) error {
+	downloadLinks := make(map[string]torrent.DownloadLinks)
+	for _, file := range t.Files {
+		url := fmt.Sprintf("%s/api/torrents/requestdl/", tb.Host)
+		query := gourl.Values{}
+		query.Add("torrent_id", t.Id)
+		query.Add("token", tb.APIKey)
+		query.Add("file_id", file.Id)
+		url += "?" + query.Encode()
+		req, _ := http.NewRequest(http.MethodGet, url, nil)
+		resp, err := tb.client.MakeRequest(req)
+		if err != nil {
+			return err
+		}
+		var data DownloadLinksResponse
+		if err = json.Unmarshal(resp, &data); err != nil {
+			return err
+		}
+		if data.Data == nil {
+			return fmt.Errorf("error getting download links")
+		}
+		idx := 0
+		link := *data.Data
+
+		dl := torrent.DownloadLinks{
+			Link:         link,
+			Filename:     t.Files[idx].Name,
+			DownloadLink: link,
+		}
+		downloadLinks[file.Id] = dl
+	}
+	t.DownloadLinks = downloadLinks
+	return nil
+}
+
+func (tb *Torbox) GetDownloadLink(t *torrent.Torrent, file *torrent.File) *torrent.DownloadLinks {
+	url := fmt.Sprintf("%s/api/torrents/requestdl/", tb.Host)
+	query := gourl.Values{}
+	query.Add("torrent_id", t.Id)
+	query.Add("token", tb.APIKey)
+	query.Add("file_id", file.Id)
+	url += "?" + query.Encode()
+	req, _ := http.NewRequest(http.MethodGet, url, nil)
+	resp, err := tb.client.MakeRequest(req)
+	if err != nil {
+		return nil
+	}
+	var data DownloadLinksResponse
+	if err = json.Unmarshal(resp, &data); err != nil {
+		return nil
+	}
+	if data.Data == nil {
+		return nil
+	}
+	link := *data.Data
+	return &torrent.DownloadLinks{
+		Link:         file.Link,
+		Filename:     file.Name,
+		DownloadLink: link,
+	}
+}
+
+func (tb *Torbox) GetCheckCached() bool {
+	return tb.CheckCached
+}
+
+func (tb *Torbox) GetTorrents() ([]*torrent.Torrent, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func New(dc config.Debrid, cache *cache.Cache) *Torbox {
+	rl := request.ParseRateLimit(dc.RateLimit)
+	headers := map[string]string{
+		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
+	}
+	client := request.NewRLHTTPClient(rl, headers)
+	return &Torbox{
+		Name:             "torbox",
+		Host:             dc.Host,
+		APIKey:           dc.APIKey,
+		DownloadUncached: dc.DownloadUncached,
+		client:           client,
+		cache:            cache,
+		MountPath:        dc.Folder,
+		logger:           logger.NewLogger(dc.Name, config.GetConfig().LogLevel, os.Stdout),
+		CheckCached:      dc.CheckCached,
+	}
+}

pkg/debrid/torbox/types.go

@@ -1,21 +1,21 @@
-package structs
+package torbox
 
 import "time"
 
-type TorboxAPIResponse[T any] struct {
+type APIResponse[T any] struct {
 	Success bool   `json:"success"`
 	Error   any    `json:"error"`
 	Detail  string `json:"detail"`
 	Data    *T     `json:"data"` // Use pointer to allow nil
 }
 
-type TorBoxAvailableResponse TorboxAPIResponse[map[string]struct {
+type AvailableResponse APIResponse[map[string]struct {
 	Name string `json:"name"`
 	Size int    `json:"size"`
 	Hash string `json:"hash"`
 }]
 
-type TorBoxAddMagnetResponse TorboxAPIResponse[struct {
+type AddMagnetResponse APIResponse[struct {
 	Id   int    `json:"torrent_id"`
 	Hash string `json:"hash"`
 }]
@@ -36,7 +36,7 @@ type torboxInfo struct {
 	Peers           int         `json:"peers"`
 	Ratio           float64     `json:"ratio"`
 	Progress        float64     `json:"progress"`
-	DownloadSpeed   int         `json:"download_speed"`
+	DownloadSpeed   int64       `json:"download_speed"`
 	UploadSpeed     int         `json:"upload_speed"`
 	Eta             int         `json:"eta"`
 	TorrentFile     bool        `json:"torrent_file"`
@@ -70,6 +70,6 @@ type torboxInfo struct {
 	TrackerMessage   interface{} `json:"tracker_message"`
 }
 
-type TorboxInfoResponse TorboxAPIResponse[torboxInfo]
+type InfoResponse APIResponse[torboxInfo]
 
-type TorBoxDownloadLinksResponse TorboxAPIResponse[string]
+type DownloadLinksResponse APIResponse[string]

pkg/debrid/torrent.go

@@ -1,117 +0,0 @@
-package debrid
-
-import (
-	"fmt"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"os"
-	"path/filepath"
-)
-
-type Arr struct {
-	Name  string `json:"name"`
-	Token string `json:"-"`
-	Host  string `json:"host"`
-}
-
-type ArrHistorySchema struct {
-	Page          int    `json:"page"`
-	PageSize      int    `json:"pageSize"`
-	SortKey       string `json:"sortKey"`
-	SortDirection string `json:"sortDirection"`
-	TotalRecords  int    `json:"totalRecords"`
-	Records       []struct {
-		ID         int    `json:"id"`
-		DownloadID string `json:"downloadId"`
-	} `json:"records"`
-}
-
-type Torrent struct {
-	Id               string                 `json:"id"`
-	InfoHash         string                 `json:"info_hash"`
-	Name             string                 `json:"name"`
-	Folder           string                 `json:"folder"`
-	Filename         string                 `json:"filename"`
-	OriginalFilename string                 `json:"original_filename"`
-	Size             int64                  `json:"size"`
-	Bytes            int64                  `json:"bytes"` // Size of only the files that are downloaded
-	Magnet           *common.Magnet         `json:"magnet"`
-	Files            []TorrentFile          `json:"files"`
-	Status           string                 `json:"status"`
-	Added            string                 `json:"added"`
-	Progress         float64                `json:"progress"`
-	Speed            int                    `json:"speed"`
-	Seeders          int                    `json:"seeders"`
-	Links            []string               `json:"links"`
-	DownloadLinks    []TorrentDownloadLinks `json:"download_links"`
-
-	Debrid Service
-	Arr    *arr.Arr
-}
-
-type TorrentDownloadLinks struct {
-	Filename     string `json:"filename"`
-	Link         string `json:"link"`
-	DownloadLink string `json:"download_link"`
-}
-
-func (t *Torrent) GetSymlinkFolder(parent string) string {
-	return filepath.Join(parent, t.Arr.Name, t.Folder)
-}
-
-func (t *Torrent) GetMountFolder(rClonePath string) (string, error) {
-	possiblePaths := []string{
-		t.OriginalFilename,
-		t.Filename,
-		common.RemoveExtension(t.OriginalFilename),
-	}
-
-	for _, path := range possiblePaths {
-		if common.FileReady(filepath.Join(rClonePath, path)) {
-			return path, nil
-		}
-	}
-	return "", fmt.Errorf("no path found")
-}
-
-func (t *Torrent) Delete() {
-	if t.Debrid == nil {
-		return
-	}
-	t.Debrid.DeleteTorrent(t)
-
-}
-
-type TorrentFile struct {
-	Id   string `json:"id"`
-	Name string `json:"name"`
-	Size int64  `json:"size"`
-	Path string `json:"path"`
-	Link string `json:"link"`
-}
-
-func getEventId(eventType string) int {
-	switch eventType {
-	case "grabbed":
-		return 1
-	case "seriesFolderDownloaded":
-		return 2
-	case "DownloadFolderImported":
-		return 3
-	case "DownloadFailed":
-		return 4
-	case "DownloadIgnored":
-		return 7
-	default:
-		return 0
-	}
-}
-
-func (t *Torrent) Cleanup(remove bool) {
-	if remove {
-		err := os.Remove(t.Filename)
-		if err != nil {
-			return
-		}
-	}
-}

pkg/debrid/torrent/torrent.go

@@ -0,0 +1,135 @@
+package torrent
+
+import (
+	"fmt"
+	"github.com/sirrobot01/debrid-blackhole/internal/cache"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+type Arr struct {
+	Name  string `json:"name"`
+	Token string `json:"-"`
+	Host  string `json:"host"`
+}
+
+type ArrHistorySchema struct {
+	Page          int    `json:"page"`
+	PageSize      int    `json:"pageSize"`
+	SortKey       string `json:"sortKey"`
+	SortDirection string `json:"sortDirection"`
+	TotalRecords  int    `json:"totalRecords"`
+	Records       []struct {
+		ID         int    `json:"id"`
+		DownloadID string `json:"downloadId"`
+	} `json:"records"`
+}
+
+type Torrent struct {
+	Id               string                   `json:"id"`
+	InfoHash         string                   `json:"info_hash"`
+	Name             string                   `json:"name"`
+	Folder           string                   `json:"folder"`
+	Filename         string                   `json:"filename"`
+	OriginalFilename string                   `json:"original_filename"`
+	Size             int64                    `json:"size"`
+	Bytes            int64                    `json:"bytes"` // Size of only the files that are downloaded
+	Magnet           *utils.Magnet            `json:"magnet"`
+	Files            []File                   `json:"files"`
+	Status           string                   `json:"status"`
+	Added            string                   `json:"added"`
+	Progress         float64                  `json:"progress"`
+	Speed            int64                    `json:"speed"`
+	Seeders          int                      `json:"seeders"`
+	Links            []string                 `json:"links"`
+	DownloadLinks    map[string]DownloadLinks `json:"download_links"`
+	MountPath        string                   `json:"mount_path"`
+
+	Debrid string `json:"debrid"`
+
+	Arr            *arr.Arr   `json:"arr"`
+	Mu             sync.Mutex `json:"-"`
+	SizeDownloaded int64      `json:"-"` // This is used for local download
+}
+
+type DownloadLinks struct {
+	Filename     string `json:"filename"`
+	Link         string `json:"link"`
+	DownloadLink string `json:"download_link"`
+}
+
+func (t *Torrent) GetSymlinkFolder(parent string) string {
+	return filepath.Join(parent, t.Arr.Name, t.Folder)
+}
+
+func (t *Torrent) GetMountFolder(rClonePath string) (string, error) {
+	possiblePaths := []string{
+		t.OriginalFilename,
+		t.Filename,
+		utils.RemoveExtension(t.OriginalFilename),
+	}
+
+	for _, path := range possiblePaths {
+		_, err := os.Stat(filepath.Join(rClonePath, path))
+		if !os.IsNotExist(err) {
+			return path, nil
+		}
+	}
+	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"`
+}
+
+func (t *Torrent) Cleanup(remove bool) {
+	if remove {
+		err := os.Remove(t.Filename)
+		if err != nil {
+			return
+		}
+	}
+}
+
+func (t *Torrent) GetFile(id string) *File {
+	for _, f := range t.Files {
+		if f.Id == id {
+			return &f
+		}
+	}
+	return nil
+}
+
+func GetLocalCache(infohashes []string, cache *cache.Cache) ([]string, map[string]bool) {
+	result := make(map[string]bool)
+	hashes := make([]string, 0)
+
+	if len(infohashes) == 0 {
+		return hashes, result
+	}
+	if len(infohashes) == 1 {
+		if cache.Exists(infohashes[0]) {
+			return hashes, map[string]bool{infohashes[0]: true}
+		}
+		return infohashes, result
+	}
+
+	cachedHashes := cache.GetMultiple(infohashes)
+	for _, h := range infohashes {
+		_, exists := cachedHashes[h]
+		if !exists {
+			hashes = append(hashes, h)
+		} else {
+			result[h] = true
+		}
+	}
+
+	return infohashes, result
+}

pkg/downloader/grab.go

@@ -0,0 +1,2 @@
+package downloader
+

pkg/downloaders/fasthttp.go

@@ -1,59 +0,0 @@
-package downloaders
-
-import (
-	"crypto/tls"
-	"fmt"
-	"github.com/valyala/fasthttp"
-	"io"
-	"os"
-)
-
-func GetFastHTTPClient() *fasthttp.Client {
-	return &fasthttp.Client{
-		TLSConfig:          &tls.Config{InsecureSkipVerify: true},
-		StreamResponseBody: true,
-	}
-}
-
-func NormalFastHTTP(client *fasthttp.Client, url, filename string) error {
-	req := fasthttp.AcquireRequest()
-	resp := fasthttp.AcquireResponse()
-	defer fasthttp.ReleaseRequest(req)
-	defer fasthttp.ReleaseResponse(resp)
-
-	req.SetRequestURI(url)
-	req.Header.SetMethod(fasthttp.MethodGet)
-
-	if err := client.Do(req, resp); err != nil {
-		return err
-	}
-
-	// Check the response status code
-	if resp.StatusCode() != fasthttp.StatusOK {
-		return fmt.Errorf("unexpected status code: %d", resp.StatusCode())
-	}
-	file, err := os.Create(filename)
-	if err != nil {
-		return err
-	}
-	defer func(file *os.File) {
-		err := file.Close()
-		if err != nil {
-			fmt.Println("Error closing file:", err)
-			return
-		}
-	}(file)
-	bodyStream := resp.BodyStream()
-	if bodyStream == nil {
-		// Write to memory and then to file
-		_, err := file.Write(resp.Body())
-		if err != nil {
-			return err
-		}
-	} else {
-		if _, err := io.Copy(file, bodyStream); err != nil {
-			return err
-		}
-	}
-	return nil
-}

pkg/downloaders/grab.go

@@ -1,55 +0,0 @@
-package downloaders
-
-import (
-	"crypto/tls"
-	"fmt"
-	"github.com/cavaliergopher/grab/v3"
-	"net/http"
-	"time"
-)
-
-func GetGrabClient() *grab.Client {
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-		Proxy:           http.ProxyFromEnvironment,
-	}
-	return &grab.Client{
-		UserAgent: "qBitTorrent",
-		HTTPClient: &http.Client{
-			Transport: tr,
-		},
-	}
-}
-
-func NormalGrab(client *grab.Client, url, filename string) error {
-	req, err := grab.NewRequest(filename, url)
-	if err != nil {
-		return err
-	}
-	resp := client.Do(req)
-	if err := resp.Err(); err != nil {
-		return err
-	}
-
-	t := time.NewTicker(2 * time.Second)
-	defer t.Stop()
-Loop:
-	for {
-		select {
-		case <-t.C:
-			fmt.Printf("  %s: transferred %d / %d bytes (%.2f%%)",
-				resp.Filename,
-				resp.BytesComplete(),
-				resp.Size(),
-				100*resp.Progress())
-
-		case <-resp.Done:
-			// download is complete
-			break Loop
-		}
-	}
-	if err := resp.Err(); err != nil {
-		return err
-	}
-	return nil
-}

pkg/downloaders/http.go

@@ -1,44 +0,0 @@
-package downloaders
-
-import (
-	"crypto/tls"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-)
-
-func GetHTTPClient() *http.Client {
-	tr := &http.Transport{
-		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
-	}
-	return &http.Client{Transport: tr}
-}
-
-func NormalHTTP(client *http.Client, url, filename string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	// Send the HTTP GET request
-	resp, err := client.Get(url)
-	if err != nil {
-		fmt.Println("Error downloading file:", err)
-		return err
-	}
-	defer resp.Body.Close()
-
-	// Check server response
-	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("server returned non-200 status: %d %s", resp.StatusCode, resp.Status)
-	}
-
-	// Write the response body to file
-	_, err = io.Copy(file, resp.Body)
-	if err != nil {
-		return err
-	}
-	return nil
-}

pkg/proxy/proxy.go

@@ -10,8 +10,10 @@ import (
 	"github.com/elazarl/goproxy"
 	"github.com/elazarl/goproxy/ext/auth"
 	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
 	"github.com/valyala/fastjson"
 	"io"
 	"net/http"
@@ -74,21 +76,19 @@ type Proxy struct {
 	username   string
 	password   string
 	cachedOnly bool
-	debrid     debrid.Service
 	logger     zerolog.Logger
 }
 
-func NewProxy(config common.Config, deb *debrid.DebridService) *Proxy {
-	cfg := config.Proxy
+func NewProxy() *Proxy {
+	cfg := config.GetConfig().Proxy
 	port := cmp.Or(os.Getenv("PORT"), cfg.Port, "8181")
 	return &Proxy{
 		port:       port,
 		enabled:    cfg.Enabled,
 		username:   cfg.Username,
 		password:   cfg.Password,
-		cachedOnly: *cfg.CachedOnly,
-		debrid:     deb.Get(),
-		logger:     common.NewLogger("Proxy", cfg.LogLevel, os.Stdout),
+		cachedOnly: cfg.CachedOnly,
+		logger:     logger.NewLogger("proxy", cfg.LogLevel, os.Stdout),
 	}
 }
 
@@ -182,7 +182,7 @@ func (item Item) getHash() string {
 	}
 
 	if strings.Contains(item.GUID, "magnet:?") {
-		magnet, err := common.GetMagnetInfo(item.GUID)
+		magnet, err := utils.GetMagnetInfo(item.GUID)
 		if err == nil && magnet != nil && magnet.InfoHash != "" {
 			return magnet.InfoHash
 		}
@@ -196,22 +196,22 @@ func (item Item) getHash() string {
 	}
 
 	if strings.Contains(magnetLink, "magnet:?") {
-		magnet, err := common.GetMagnetInfo(magnetLink)
+		magnet, err := utils.GetMagnetInfo(magnetLink)
 		if err == nil && magnet != nil && magnet.InfoHash != "" {
 			return magnet.InfoHash
 		}
 	}
 
 	//Check Description for infohash
-	hash := common.ExtractInfoHash(item.Description)
+	hash := utils.ExtractInfoHash(item.Description)
 	if hash == "" {
 		// Check Title for infohash
-		hash = common.ExtractInfoHash(item.Comments)
+		hash = utils.ExtractInfoHash(item.Comments)
 	}
 	infohash = hash
 	if infohash == "" {
 		if strings.Contains(magnetLink, "http") {
-			h, _ := common.GetInfohashFromURL(magnetLink)
+			h, _ := utils.GetInfohashFromURL(magnetLink)
 			if h != "" {
 				infohash = h
 			}
@@ -226,6 +226,8 @@ func (p *Proxy) ProcessXMLResponse(resp *http.Response) *http.Response {
 		return resp
 	}
 
+	svc := service.GetService()
+
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
 		p.logger.Info().Msgf("Error reading response body: %v", err)
@@ -260,7 +262,7 @@ func (p *Proxy) ProcessXMLResponse(resp *http.Response) *http.Response {
 			hashes = append(hashes, hash)
 		}
 	}
-	availableHashesMap := p.debrid.IsAvailable(hashes)
+	availableHashesMap := svc.Debrid.Get().IsAvailable(hashes)
 	newItems := make([]Item, 0, len(rss.Channel.Items))
 
 	if len(hashes) > 0 {

pkg/qbit/downloader.go

@@ -0,0 +1,205 @@
+package qbit
+
+import (
+	"crypto/tls"
+	"fmt"
+	"github.com/cavaliergopher/grab/v3"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	debrid "github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"net/http"
+	"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.DownloadLinks))
+	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)
+	}
+
+	tr := &http.Transport{
+		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		Proxy:           http.ProxyFromEnvironment,
+	}
+	client := &grab.Client{
+		UserAgent: "qBitTorrent",
+		HTTPClient: &http.Client{
+			Transport: tr,
+		},
+	}
+	for _, link := range debridTorrent.DownloadLinks {
+		if link.DownloadLink == "" {
+			q.logger.Info().Msgf("No download link found for %s", link.Filename)
+			continue
+		}
+		wg.Add(1)
+		semaphore <- struct{}{}
+		go func(link debrid.DownloadLinks) {
+			defer wg.Done()
+			defer func() { <-semaphore }()
+			filename := link.Filename
+
+			err := Download(
+				client,
+				link.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)
+			}
+		}(link)
+	}
+	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
+	}
+	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentFolder) // /mnt/symlinks/{category}/MyTVShow/
+	err = os.MkdirAll(torrentSymlinkPath, os.ModePerm)
+	if err != nil {
+		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
+	}
+
+	pending := make(map[string]debrid.File)
+	for _, file := range files {
+		pending[file.Path] = file
+	}
+	ticker := time.NewTicker(200 * time.Millisecond)
+	defer ticker.Stop()
+
+	for len(pending) > 0 {
+		<-ticker.C
+		for path, file := range pending {
+			fullFilePath := filepath.Join(torrentRclonePath, file.Path)
+			if _, err := os.Stat(fullFilePath); !os.IsNotExist(err) {
+				q.logger.Info().Msgf("File is ready: %s", file.Path)
+				q.createSymLink(torrentSymlinkPath, torrentRclonePath, file)
+				delete(pending, path)
+			}
+		}
+	}
+	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) {
+
+	// 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)
+	}
+}

pkg/qbit/http.go

@@ -1,24 +1,17 @@
-package server
+package qbit
 
 import (
 	"context"
 	"encoding/base64"
 	"github.com/go-chi/chi/v5"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
 	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit/shared"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
 	"net/http"
 	"path/filepath"
 	"strings"
 )
 
-type qbitHandler struct {
-	qbit   *shared.QBit
-	logger zerolog.Logger
-	debug  bool
-}
-
 func decodeAuthHeader(header string) (string, string, error) {
 	encodedTokens := strings.Split(header, " ")
 	if len(encodedTokens) != 2 {
@@ -40,7 +33,7 @@ func decodeAuthHeader(header string) (string, string, error) {
 	return host, token, nil
 }
 
-func (q *qbitHandler) CategoryContext(next http.Handler) http.Handler {
+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 == "" {
@@ -59,18 +52,22 @@ func (q *qbitHandler) CategoryContext(next http.Handler) http.Handler {
 	})
 }
 
-func (q *qbitHandler) authContext(next http.Handler) http.Handler {
+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)
-		a := &arr.Arr{
-			Name: category,
+		svc := service.GetService()
+		// Check if arr exists
+		a := svc.Arr.Get(category)
+		if a == nil {
+			a = arr.New(category, "", "", false)
 		}
 		if err == nil {
 			a.Host = strings.TrimSpace(host)
 			a.Token = strings.TrimSpace(token)
 		}
-		q.qbit.Arrs.AddOrUpdate(a)
+
+		svc.Arr.AddOrUpdate(a)
 		ctx := context.WithValue(r.Context(), "arr", a)
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
@@ -96,30 +93,30 @@ func HashesCtx(next http.Handler) http.Handler {
 	})
 }
 
-func (q *qbitHandler) handleLogin(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleLogin(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write([]byte("Ok."))
 }
 
-func (q *qbitHandler) handleVersion(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleVersion(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write([]byte("v4.3.2"))
 }
 
-func (q *qbitHandler) handleWebAPIVersion(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleWebAPIVersion(w http.ResponseWriter, r *http.Request) {
 	_, _ = w.Write([]byte("2.7"))
 }
 
-func (q *qbitHandler) handlePreferences(w http.ResponseWriter, r *http.Request) {
-	preferences := shared.NewAppPreferences()
+func (q *QBit) handlePreferences(w http.ResponseWriter, r *http.Request) {
+	preferences := NewAppPreferences()
 
-	preferences.WebUiUsername = q.qbit.Username
-	preferences.SavePath = q.qbit.DownloadFolder
-	preferences.TempPath = filepath.Join(q.qbit.DownloadFolder, "temp")
+	preferences.WebUiUsername = q.Username
+	preferences.SavePath = q.DownloadFolder
+	preferences.TempPath = filepath.Join(q.DownloadFolder, "temp")
 
-	common.JSONResponse(w, preferences, http.StatusOK)
+	request.JSONResponse(w, preferences, http.StatusOK)
 }
 
-func (q *qbitHandler) handleBuildInfo(w http.ResponseWriter, r *http.Request) {
-	res := shared.BuildInfo{
+func (q *QBit) handleBuildInfo(w http.ResponseWriter, r *http.Request) {
+	res := BuildInfo{
 		Bitness:    64,
 		Boost:      "1.75.0",
 		Libtorrent: "1.2.11.0",
@@ -127,24 +124,24 @@ func (q *qbitHandler) handleBuildInfo(w http.ResponseWriter, r *http.Request) {
 		Qt:         "5.15.2",
 		Zlib:       "1.2.11",
 	}
-	common.JSONResponse(w, res, http.StatusOK)
+	request.JSONResponse(w, res, http.StatusOK)
 }
 
-func (q *qbitHandler) shutdown(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleShutdown(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentsInfo(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)
 	filter := strings.Trim(r.URL.Query().Get("filter"), "")
 	hashes, _ := ctx.Value("hashes").([]string)
-	torrents := q.qbit.Storage.GetAll(category, filter, hashes)
-	common.JSONResponse(w, torrents, http.StatusOK)
+	torrents := q.Storage.GetAll(category, filter, hashes)
+	request.JSONResponse(w, torrents, http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 
 	// Parse form based on content type
@@ -178,7 +175,7 @@ func (q *qbitHandler) handleTorrentsAdd(w http.ResponseWriter, r *http.Request)
 			urlList = append(urlList, strings.TrimSpace(u))
 		}
 		for _, url := range urlList {
-			if err := q.qbit.AddMagnet(ctx, url, category); err != nil {
+			if err := q.AddMagnet(ctx, url, category); err != nil {
 				q.logger.Info().Msgf("Error adding magnet: %v", err)
 				http.Error(w, err.Error(), http.StatusBadRequest)
 				return
@@ -191,7 +188,7 @@ func (q *qbitHandler) 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.qbit.AddTorrent(ctx, fileHeader, category); err != nil {
+				if err := q.AddTorrent(ctx, fileHeader, category); err != nil {
 					q.logger.Info().Msgf("Error adding torrent: %v", err)
 					http.Error(w, err.Error(), http.StatusBadRequest)
 					return
@@ -209,75 +206,79 @@ func (q *qbitHandler) handleTorrentsAdd(w http.ResponseWriter, r *http.Request)
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	hashes, _ := ctx.Value("hashes").([]string)
 	if len(hashes) == 0 {
 		http.Error(w, "No hashes provided", http.StatusBadRequest)
 		return
 	}
+	category := ctx.Value("category").(string)
 	for _, hash := range hashes {
-		q.qbit.Storage.Delete(hash)
+		q.Storage.Delete(hash, category)
 	}
 
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentsPause(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)
 	for _, hash := range hashes {
-		torrent := q.qbit.Storage.Get(hash)
+		torrent := q.Storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
-		go q.qbit.PauseTorrent(torrent)
+		go q.PauseTorrent(torrent)
 	}
 
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentsResume(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)
 	for _, hash := range hashes {
-		torrent := q.qbit.Storage.Get(hash)
+		torrent := q.Storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
-		go q.qbit.ResumeTorrent(torrent)
+		go q.ResumeTorrent(torrent)
 	}
 
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentRecheck(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)
 	for _, hash := range hashes {
-		torrent := q.qbit.Storage.Get(hash)
+		torrent := q.Storage.Get(hash, category)
 		if torrent == nil {
 			continue
 		}
-		go q.qbit.RefreshTorrent(torrent)
+		go q.RefreshTorrent(torrent)
 	}
 
 	w.WriteHeader(http.StatusOK)
 }
 
-func (q *qbitHandler) handleCategories(w http.ResponseWriter, r *http.Request) {
-	var categories = map[string]shared.TorrentCategory{}
-	for _, cat := range q.qbit.Categories {
-		path := filepath.Join(q.qbit.DownloadFolder, cat)
-		categories[cat] = shared.TorrentCategory{
+func (q *QBit) handleCategories(w http.ResponseWriter, r *http.Request) {
+	var categories = map[string]TorrentCategory{}
+	for _, cat := range q.Categories {
+		path := filepath.Join(q.DownloadFolder, cat)
+		categories[cat] = TorrentCategory{
 			Name:     cat,
 			SavePath: path,
 		}
 	}
-	common.JSONResponse(w, categories, http.StatusOK)
+	request.JSONResponse(w, categories, http.StatusOK)
 }
 
-func (q *qbitHandler) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
@@ -290,41 +291,44 @@ func (q *qbitHandler) handleCreateCategory(w http.ResponseWriter, r *http.Reques
 		return
 	}
 
-	q.qbit.Categories = append(q.qbit.Categories, name)
+	q.Categories = append(q.Categories, name)
 
-	common.JSONResponse(w, nil, http.StatusOK)
+	request.JSONResponse(w, nil, http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentProperties(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.qbit.Storage.Get(hash)
-	properties := q.qbit.GetTorrentProperties(torrent)
-	common.JSONResponse(w, properties, http.StatusOK)
+	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
+
+	properties := q.GetTorrentProperties(torrent)
+	request.JSONResponse(w, properties, http.StatusOK)
 }
 
-func (q *qbitHandler) handleTorrentFiles(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.qbit.Storage.Get(hash)
+	torrent := q.Storage.Get(hash, ctx.Value("category").(string))
 	if torrent == nil {
 		return
 	}
-	files := q.qbit.GetTorrentFiles(torrent)
-	common.JSONResponse(w, files, http.StatusOK)
+	files := q.GetTorrentFiles(torrent)
+	request.JSONResponse(w, files, http.StatusOK)
 }
 
-func (q *qbitHandler) handleSetCategory(w http.ResponseWriter, r *http.Request) {
+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.qbit.Storage.GetAll("", "", hashes)
+	torrents := q.Storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
 		torrent.Category = category
-		q.qbit.Storage.AddOrUpdate(torrent)
+		q.Storage.AddOrUpdate(torrent)
 	}
-	common.JSONResponse(w, nil, http.StatusOK)
+	request.JSONResponse(w, nil, http.StatusOK)
 }
 
-func (q *qbitHandler) handleAddTorrentTags(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleAddTorrentTags(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
@@ -336,14 +340,14 @@ func (q *qbitHandler) handleAddTorrentTags(w http.ResponseWriter, r *http.Reques
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.qbit.Storage.GetAll("", "", hashes)
+	torrents := q.Storage.GetAll("", "", hashes)
 	for _, t := range torrents {
-		q.qbit.SetTorrentTags(t, tags)
+		q.SetTorrentTags(t, tags)
 	}
-	common.JSONResponse(w, nil, http.StatusOK)
+	request.JSONResponse(w, nil, http.StatusOK)
 }
 
-func (q *qbitHandler) handleRemoveTorrentTags(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleRemoveTorrentTags(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
@@ -355,19 +359,19 @@ func (q *qbitHandler) handleRemoveTorrentTags(w http.ResponseWriter, r *http.Req
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	torrents := q.qbit.Storage.GetAll("", "", hashes)
+	torrents := q.Storage.GetAll("", "", hashes)
 	for _, torrent := range torrents {
-		q.qbit.RemoveTorrentTags(torrent, tags)
+		q.RemoveTorrentTags(torrent, tags)
 
 	}
-	common.JSONResponse(w, nil, http.StatusOK)
+	request.JSONResponse(w, nil, http.StatusOK)
 }
 
-func (q *qbitHandler) handleGetTags(w http.ResponseWriter, r *http.Request) {
-	common.JSONResponse(w, q.qbit.Tags, http.StatusOK)
+func (q *QBit) handleGetTags(w http.ResponseWriter, r *http.Request) {
+	request.JSONResponse(w, q.Tags, http.StatusOK)
 }
 
-func (q *qbitHandler) handleCreateTags(w http.ResponseWriter, r *http.Request) {
+func (q *QBit) handleCreateTags(w http.ResponseWriter, r *http.Request) {
 	err := r.ParseForm()
 	if err != nil {
 		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
@@ -377,6 +381,6 @@ func (q *qbitHandler) handleCreateTags(w http.ResponseWriter, r *http.Request) {
 	for i, tag := range tags {
 		tags[i] = strings.TrimSpace(tag)
 	}
-	q.qbit.AddTags(tags)
-	common.JSONResponse(w, nil, http.StatusOK)
+	q.AddTags(tags)
+	request.JSONResponse(w, nil, http.StatusOK)
 }

pkg/qbit/import.go

@@ -1,13 +1,14 @@
-package server
+package qbit
 
 import (
 	"fmt"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
+	"time"
+
 	"github.com/google/uuid"
-	"github.com/sirrobot01/debrid-blackhole/common"
 	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
 	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit/shared"
-	"time"
 )
 
 type ImportRequest struct {
@@ -62,15 +63,21 @@ func (i *ImportRequest) Complete() {
 	i.CompletedAt = time.Now()
 }
 
-func (i *ImportRequest) Process(q *shared.QBit) (err error) {
+func (i *ImportRequest) Process(q *QBit) (err error) {
 	// Use this for now.
 	// This sends the torrent to the arr
-	magnet, err := common.GetMagnetFromUrl(i.URI)
-	torrent := q.CreateTorrentFromMagnet(magnet, i.Arr.Name, "manual")
-	debridTorrent, err := debrid.ProcessTorrent(q.Debrid, magnet, i.Arr, i.IsSymlink)
+	svc := service.GetService()
+	magnet, err := utils.GetMagnetFromUrl(i.URI)
+	if err != nil {
+		return fmt.Errorf("error parsing magnet link: %w", err)
+	}
+	torrent := CreateTorrentFromMagnet(magnet, i.Arr.Name, "manual")
+	debridTorrent, err := debrid.ProcessTorrent(svc.Debrid, magnet, i.Arr, i.IsSymlink)
 	if err != nil || debridTorrent == nil {
+		fmt.Println("Error deleting torrent: ", err)
 		if debridTorrent != nil {
-			go debridTorrent.Delete()
+			dbClient := service.GetDebrid().GetByName(debridTorrent.Debrid)
+			go dbClient.DeleteTorrent(debridTorrent)
 		}
 		if err == nil {
 			err = fmt.Errorf("failed to process torrent")

pkg/qbit/main.go

@@ -1,18 +0,0 @@
-package qbit
-
-import (
-	"context"
-	"fmt"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit/server"
-)
-
-func Start(ctx context.Context, config *common.Config, deb *debrid.DebridService, arrs *arr.Storage) error {
-	srv := server.NewServer(config, deb, arrs)
-	if err := srv.Start(ctx); err != nil {
-		return fmt.Errorf("failed to start qbit server: %w", err)
-	}
-	return nil
-}

pkg/qbit/misc.go

@@ -0,0 +1,50 @@
+package qbit
+
+import (
+	"github.com/google/uuid"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	debrid "github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+func checkFileLoop(wg *sync.WaitGroup, dir string, file debrid.File, ready chan<- debrid.File) {
+	defer wg.Done()
+	ticker := time.NewTicker(1 * time.Second) // Check every second
+	defer ticker.Stop()
+	path := filepath.Join(dir, file.Path)
+	for {
+		select {
+		case <-ticker.C:
+			_, err := os.Stat(path)
+			if !os.IsNotExist(err) {
+				ready <- file
+				return
+			}
+		}
+	}
+}
+
+func CreateTorrentFromMagnet(magnet *utils.Magnet, category, source string) *Torrent {
+	torrent := &Torrent{
+		ID:        uuid.NewString(),
+		Hash:      strings.ToLower(magnet.InfoHash),
+		Name:      magnet.Name,
+		Size:      magnet.Size,
+		Category:  category,
+		Source:    source,
+		State:     "downloading",
+		MagnetUri: magnet.Link,
+
+		Tracker:    "udp://tracker.opentrackr.org:1337",
+		UpLimit:    -1,
+		DlLimit:    -1,
+		AutoTmm:    false,
+		Ratio:      1,
+		RatioLimit: 1,
+	}
+	return torrent
+}

pkg/qbit/qbit.go

@@ -1,12 +1,12 @@
-package shared
+package qbit
 
 import (
 	"cmp"
 	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
 	"os"
+	"path/filepath"
 )
 
 type QBit struct {
@@ -15,18 +15,17 @@ type QBit struct {
 	Port            string   `json:"port"`
 	DownloadFolder  string   `json:"download_folder"`
 	Categories      []string `json:"categories"`
-	Debrid          *debrid.DebridService
 	Storage         *TorrentStorage
 	debug           bool
 	logger          zerolog.Logger
-	Arrs            *arr.Storage
 	Tags            []string
 	RefreshInterval int
 }
 
-func NewQBit(config *common.Config, deb *debrid.DebridService, logger zerolog.Logger, arrs *arr.Storage) *QBit {
-	cfg := config.QBitTorrent
-	port := cmp.Or(cfg.Port, os.Getenv("QBIT_PORT"), "8182")
+func New() *QBit {
+	_cfg := config.GetConfig()
+	cfg := _cfg.QBitTorrent
+	port := cmp.Or(cfg.Port, os.Getenv("QBIT_PORT"), "8282")
 	refreshInterval := cmp.Or(cfg.RefreshInterval, 10)
 	return &QBit{
 		Username:        cfg.Username,
@@ -34,10 +33,8 @@ func NewQBit(config *common.Config, deb *debrid.DebridService, logger zerolog.Lo
 		Port:            port,
 		DownloadFolder:  cfg.DownloadFolder,
 		Categories:      cfg.Categories,
-		Debrid:          deb,
-		Storage:         NewTorrentStorage("torrents.json"),
-		logger:          logger,
-		Arrs:            arrs,
+		Storage:         NewTorrentStorage(filepath.Join(_cfg.Path, "torrents.json")),
+		logger:          logger.NewLogger("qbit", cfg.LogLevel, os.Stdout),
 		RefreshInterval: refreshInterval,
 	}
 }

pkg/qbit/routes.go

@@ -0,0 +1,43 @@
+package qbit
+
+import (
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+func (q *QBit) Routes() http.Handler {
+	r := chi.NewRouter()
+	r.Use(q.CategoryContext)
+	r.Post("/auth/login", q.handleLogin)
+
+	r.Group(func(r chi.Router) {
+		r.Use(q.authContext)
+		r.Route("/torrents", func(r chi.Router) {
+			r.Use(HashesCtx)
+			r.Get("/info", q.handleTorrentsInfo)
+			r.Post("/add", q.handleTorrentsAdd)
+			r.Post("/delete", q.handleTorrentsDelete)
+			r.Get("/categories", q.handleCategories)
+			r.Post("/createCategory", q.handleCreateCategory)
+			r.Post("/setCategory", q.handleSetCategory)
+			r.Post("/addTags", q.handleAddTorrentTags)
+			r.Post("/removeTags", q.handleRemoveTorrentTags)
+			r.Post("/createTags", q.handleCreateTags)
+			r.Get("/tags", q.handleGetTags)
+			r.Get("/pause", q.handleTorrentsPause)
+			r.Get("/resume", q.handleTorrentsResume)
+			r.Get("/recheck", q.handleTorrentRecheck)
+			r.Get("/properties", q.handleTorrentProperties)
+			r.Get("/files", q.handleTorrentFiles)
+		})
+
+		r.Route("/app", func(r chi.Router) {
+			r.Get("/version", q.handleVersion)
+			r.Get("/webapiVersion", q.handleWebAPIVersion)
+			r.Get("/preferences", q.handlePreferences)
+			r.Get("/buildInfo", q.handleBuildInfo)
+			r.Get("/shutdown", q.handleShutdown)
+		})
+	})
+	return r
+}

pkg/qbit/server/qbit_routes.go

@@ -1,48 +0,0 @@
-package server
-
-import (
-	"github.com/go-chi/chi/v5"
-	"net/http"
-)
-
-func (q *qbitHandler) Routes(r chi.Router) http.Handler {
-	r.Route("/api/v2", func(r chi.Router) {
-		//if q.debug {
-		//	r.Use(middleware.Logger)
-		//}
-		r.Use(q.CategoryContext)
-		r.Post("/auth/login", q.handleLogin)
-
-		r.Group(func(r chi.Router) {
-			r.Use(q.authContext)
-			r.Route("/torrents", func(r chi.Router) {
-				r.Use(HashesCtx)
-				r.Get("/info", q.handleTorrentsInfo)
-				r.Post("/add", q.handleTorrentsAdd)
-				r.Post("/delete", q.handleTorrentsDelete)
-				r.Get("/categories", q.handleCategories)
-				r.Post("/createCategory", q.handleCreateCategory)
-				r.Post("/setCategory", q.handleSetCategory)
-				r.Post("/addTags", q.handleAddTorrentTags)
-				r.Post("/removeTags", q.handleRemoveTorrentTags)
-				r.Post("/createTags", q.handleCreateTags)
-				r.Get("/tags", q.handleGetTags)
-				r.Get("/pause", q.handleTorrentsPause)
-				r.Get("/resume", q.handleTorrentsResume)
-				r.Get("/recheck", q.handleTorrentRecheck)
-				r.Get("/properties", q.handleTorrentProperties)
-				r.Get("/files", q.handleTorrentFiles)
-			})
-
-			r.Route("/app", func(r chi.Router) {
-				r.Get("/version", q.handleVersion)
-				r.Get("/webapiVersion", q.handleWebAPIVersion)
-				r.Get("/preferences", q.handlePreferences)
-				r.Get("/buildInfo", q.handleBuildInfo)
-				r.Get("/shutdown", q.shutdown)
-			})
-		})
-
-	})
-	return r
-}

pkg/qbit/server/templates/download.html

@@ -1,74 +0,0 @@
-{{ define "download" }}
-    <div class="container mt-4">
-        <div class="card">
-            <div class="card-header">
-                <h4 class="mb-0"><i class="bi bi-cloud-download me-2"></i>Add New Download</h4>
-            </div>
-            <div class="card-body">
-                <form id="downloadForm">
-                    <div class="mb-3">
-                        <label for="magnetURI" class="form-label">Magnet Link or Torrent URL</label>
-                        <textarea class="form-control" id="magnetURI" rows="3" placeholder="Paste your magnet link here..."></textarea>
-                    </div>
-
-                    <div class="mb-3">
-                        <label for="category" class="form-label">Enter Category</label>
-                        <input type="text" class="form-control" id="category" placeholder="Enter Category(e.g sonarr, radarr, radarr4k)">
-                    </div>
-
-                    <div class="mb-3">
-                        <div class="form-check">
-                            <input class="form-check-input" type="checkbox" id="isSymlink">
-                            <label class="form-check-label" for="isSymlink">
-                                Download real files instead of symlinks
-                            </label>
-                        </div>
-                    </div>
-
-                    <button type="submit" class="btn btn-primary" id="submitDownload">
-                        <i class="bi bi-cloud-upload me-2"></i>Add to Download Queue
-                    </button>
-                </form>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        document.addEventListener('DOMContentLoaded', () => {
-
-            // Handle form submission
-            document.getElementById('downloadForm').addEventListener('submit', async (e) => {
-                e.preventDefault();
-                const submitBtn = document.getElementById('submitDownload');
-                const originalText = submitBtn.innerHTML;
-
-                submitBtn.disabled = true;
-                submitBtn.innerHTML = '<span class="spinner-border spinner-border-sm me-2"></span>Adding...';
-
-                try {
-                    const response = await fetch('/internal/add', {
-                        method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json'
-                        },
-                        body: JSON.stringify({
-                            url: document.getElementById('magnetURI').value,
-                            arr: document.getElementById('category').value,
-                            notSymlink: document.getElementById('isSymlink').checked
-                        })
-                    });
-
-                    if (!response.ok) throw new Error(await response.text());
-
-                    alert('Download added successfully!');
-                    document.getElementById('magnetURI').value = '';
-                } catch (error) {
-                    alert(`Error adding download: ${error.message}`);
-                } finally {
-                    submitBtn.disabled = false;
-                    submitBtn.innerHTML = originalText;
-                }
-            });
-        });
-    </script>
-{{ end }}

pkg/qbit/server/templates/index.html

@@ -1,149 +0,0 @@
-{{ define "index" }}
-    <div class="container mt-4">
-        <div class="card">
-            <div class="card-header d-flex justify-content-between align-items-center">
-                <h4 class="mb-0"><i class="bi bi-table me-2"></i>Active Torrents</h4>
-                <div>
-                    <button class="btn btn-outline-secondary btn-sm me-2" id="refreshBtn">
-                        <i class="bi bi-arrow-clockwise me-1"></i>Refresh
-                    </button>
-                    <select class="form-select form-select-sm d-inline-block w-auto" id="categoryFilter">
-                        <option value="">All Categories</option>
-                    </select>
-                </div>
-            </div>
-            <div class="card-body p-0">
-                <div class="table-responsive">
-                    <table class="table table-hover mb-0">
-                        <thead>
-                        <tr>
-                            <th>Name</th>
-                            <th>Size</th>
-                            <th>Progress</th>
-                            <th>Speed</th>
-                            <th>Category</th>
-                            <th>Debrid</th>
-                            <th>State</th>
-                            <th>Actions</th>
-                        </tr>
-                        </thead>
-                        <tbody id="torrentsList">
-                        </tbody>
-                    </table>
-                </div>
-            </div>
-        </div>
-    </div>
-    <script>
-        const torrentRowTemplate = (torrent) => `
-        <tr>
-            <td class="text-break">${torrent.name}</td>
-            <td>${formatBytes(torrent.size)}</td>
-            <td style="min-width: 150px;">
-                <div class="progress" style="height: 8px;">
-                    <div class="progress-bar" role="progressbar"
-                         style="width: ${(torrent.progress * 100).toFixed(1)}%"
-                         aria-valuenow="${(torrent.progress * 100).toFixed(1)}"
-                         aria-valuemin="0"
-                         aria-valuemax="100"></div>
-                </div>
-                <small class="text-muted">${(torrent.progress * 100).toFixed(1)}%</small>
-            </td>
-            <td>${formatSpeed(torrent.dlspeed)}</td>
-            <td><span class="badge bg-secondary">${torrent.category || 'None'}</span></td>
-            <td>${torrent.debrid || 'None'}</td>
-            <td><span class="badge ${getStateColor(torrent.state)}">${torrent.state}</span></td>
-            <td>
-                <button class="btn btn-sm btn-outline-danger" onclick="deleteTorrent('${torrent.hash}')">
-                    <i class="bi bi-trash"></i>
-                </button>
-            </td>
-        </tr>
-    `;
-
-        function formatBytes(bytes) {
-            if (!bytes) return '0 B';
-            const k = 1024;
-            const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-            const i = Math.floor(Math.log(bytes) / Math.log(k));
-            return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
-        }
-
-        function formatSpeed(speed) {
-            return `${formatBytes(speed)}/s`;
-        }
-
-        function getStateColor(state) {
-            const stateColors = {
-                'downloading': 'bg-primary',
-                'pausedup': 'bg-success',
-                'error': 'bg-danger',
-            };
-            return stateColors[state?.toLowerCase()] || 'bg-secondary';
-        }
-
-        let refreshInterval;
-
-        async function loadTorrents() {
-            try {
-                const response = await fetch('/internal/torrents');
-                const torrents = await response.json();
-
-                const tbody = document.getElementById('torrentsList');
-                tbody.innerHTML = torrents.map(torrent => torrentRowTemplate(torrent)).join('');
-
-                // Update category filter options
-                let category = document.getElementById('categoryFilter').value;
-                document.querySelectorAll('#torrentsList tr').forEach(row => {
-                    const rowCategory = row.querySelector('td:nth-child(5)').textContent;
-                    row.style.display = (!category || rowCategory.includes(category)) ? '' : 'none';
-                });
-                updateCategoryFilter(torrents);
-            } catch (error) {
-                console.error('Error loading torrents:', error);
-            }
-        }
-
-        function updateCategoryFilter(torrents) {
-            const categories = [...new Set(torrents.map(t => t.category).filter(Boolean))];
-            const select = document.getElementById('categoryFilter');
-            const currentValue = select.value;
-
-            select.innerHTML = '<option value="">All Categories</option>' +
-                categories.map(cat => `<option value="${cat}" ${cat === currentValue ? 'selected' : ''}>${cat}</option>`).join('');
-        }
-
-        async function deleteTorrent(hash) {
-            if (!confirm('Are you sure you want to delete this torrent?')) return;
-
-            try {
-                await fetch(`/internal/torrents/${hash}`, {
-                    method: 'DELETE'
-                });
-                await loadTorrents();
-            } catch (error) {
-                console.error('Error deleting torrent:', error);
-                alert('Failed to delete torrent');
-            }
-        }
-
-        document.addEventListener('DOMContentLoaded', () => {
-            loadTorrents();
-            refreshInterval = setInterval(loadTorrents, 5000); // Refresh every 5 seconds
-
-            document.getElementById('refreshBtn').addEventListener('click', loadTorrents);
-
-            document.getElementById('categoryFilter').addEventListener('change', (e) => {
-                const category = e.target.value;
-                document.querySelectorAll('#torrentsList tr').forEach(row => {
-                    const rowCategory = row.querySelector('td:nth-child(5)').textContent;
-                    row.style.display = (!category || rowCategory.includes(category)) ? '' : 'none';
-                });
-            });
-        });
-
-        window.addEventListener('beforeunload', () => {
-            clearInterval(refreshInterval);
-        });
-    </script>
-{{ end }}

pkg/qbit/server/ui_handlers.go

@@ -1,248 +0,0 @@
-package server
-
-import (
-	"embed"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"github.com/go-chi/chi/v5"
-	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit/shared"
-	"github.com/sirrobot01/debrid-blackhole/pkg/version"
-	"html/template"
-	"net/http"
-	"strings"
-)
-
-type AddRequest struct {
-	Url        string   `json:"url"`
-	Arr        string   `json:"arr"`
-	File       string   `json:"file"`
-	NotSymlink bool     `json:"notSymlink"`
-	Content    string   `json:"content"`
-	Seasons    []string `json:"seasons"`
-	Episodes   []string `json:"episodes"`
-}
-
-type ArrResponse struct {
-	Name string `json:"name"`
-	Url  string `json:"url"`
-}
-
-type ContentResponse struct {
-	ID    string `json:"id"`
-	Title string `json:"title"`
-	Type  string `json:"type"`
-	ArrID string `json:"arr"`
-}
-
-type RepairRequest struct {
-	ArrName  string   `json:"arr"`
-	MediaIds []string `json:"mediaIds"`
-	Async    bool     `json:"async"`
-}
-
-//go:embed templates/*
-var content embed.FS
-
-type uiHandler struct {
-	qbit   *shared.QBit
-	logger zerolog.Logger
-	debug  bool
-}
-
-var templates *template.Template
-
-func init() {
-	templates = template.Must(template.ParseFS(
-		content,
-		"templates/layout.html",
-		"templates/index.html",
-		"templates/download.html",
-		"templates/repair.html",
-		"templates/config.html",
-	))
-}
-
-func (u *uiHandler) IndexHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "index",
-		"Title": "Torrents",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (u *uiHandler) DownloadHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "download",
-		"Title": "Download",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (u *uiHandler) RepairHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "repair",
-		"Title": "Repair",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (u *uiHandler) ConfigHandler(w http.ResponseWriter, r *http.Request) {
-	data := map[string]interface{}{
-		"Page":  "config",
-		"Title": "Config",
-	}
-	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-		return
-	}
-}
-
-func (u *uiHandler) handleGetArrs(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	common.JSONResponse(w, u.qbit.Arrs.GetAll(), http.StatusOK)
-}
-
-func (u *uiHandler) handleAddContent(w http.ResponseWriter, r *http.Request) {
-	var req AddRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	_arr := u.qbit.Arrs.Get(req.Arr)
-	if _arr == nil {
-		_arr = arr.NewArr(req.Arr, "", "", arr.Sonarr)
-	}
-	importReq := NewImportRequest(req.Url, _arr, !req.NotSymlink)
-	err := importReq.Process(u.qbit)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-	common.JSONResponse(w, importReq, http.StatusOK)
-}
-
-func (u *uiHandler) handleCheckCached(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	_hashes := r.URL.Query().Get("hash")
-	if _hashes == "" {
-		http.Error(w, "No hashes provided", http.StatusBadRequest)
-		return
-	}
-	hashes := strings.Split(_hashes, ",")
-	if len(hashes) == 0 {
-		http.Error(w, "No hashes provided", http.StatusBadRequest)
-		return
-	}
-	db := r.URL.Query().Get("debrid")
-	var deb debrid.Service
-	if db == "" {
-		// use the first debrid
-		deb = u.qbit.Debrid.Get()
-	} else {
-		deb = u.qbit.Debrid.GetByName(db)
-	}
-	if deb == nil {
-		http.Error(w, "Invalid debrid", http.StatusBadRequest)
-		return
-	}
-	res := deb.IsAvailable(hashes)
-	result := make(map[string]bool)
-	for _, h := range hashes {
-		_, exists := res[h]
-		result[h] = exists
-	}
-	common.JSONResponse(w, result, http.StatusOK)
-}
-
-func (u *uiHandler) handleRepairMedia(w http.ResponseWriter, r *http.Request) {
-	var req RepairRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	_arr := u.qbit.Arrs.Get(req.ArrName)
-	if _arr == nil {
-		http.Error(w, "No Arrs found to repair", http.StatusNotFound)
-		return
-	}
-
-	mediaIds := req.MediaIds
-	if len(mediaIds) == 0 {
-		mediaIds = []string{""}
-	}
-
-	if req.Async {
-		for _, tvId := range mediaIds {
-			go func() {
-				err := _arr.Repair(tvId)
-				if err != nil {
-					u.logger.Info().Msgf("Failed to repair: %v", err)
-				}
-			}()
-		}
-		common.JSONResponse(w, "Repair process started", http.StatusOK)
-		return
-	}
-
-	var errs []error
-	for _, tvId := range mediaIds {
-		if err := _arr.Repair(tvId); err != nil {
-			errs = append(errs, err)
-		}
-	}
-
-	if len(errs) > 0 {
-		combinedErr := errors.Join(errs...)
-		http.Error(w, fmt.Sprintf("Failed to repair: %v", combinedErr), http.StatusInternalServerError)
-		return
-	}
-
-	common.JSONResponse(w, "Repair completed", http.StatusOK)
-}
-
-func (u *uiHandler) handleGetVersion(w http.ResponseWriter, r *http.Request) {
-	v := version.GetInfo()
-	w.Header().Set("Content-Type", "application/json")
-	common.JSONResponse(w, v, http.StatusOK)
-}
-
-func (u *uiHandler) handleGetTorrents(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	common.JSONResponse(w, u.qbit.Storage.GetAll("", "", nil), http.StatusOK)
-}
-
-func (u *uiHandler) handleDeleteTorrent(w http.ResponseWriter, r *http.Request) {
-	hash := chi.URLParam(r, "hash")
-	if hash == "" {
-		http.Error(w, "No hash provided", http.StatusBadRequest)
-		return
-	}
-	u.qbit.Storage.Delete(hash)
-	w.WriteHeader(http.StatusOK)
-}
-
-func (u *uiHandler) handleGetConfig(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	config := common.CONFIG
-	arrCfgs := make([]common.ArrConfig, 0)
-	for _, a := range u.qbit.Arrs.GetAll() {
-		arrCfgs = append(arrCfgs, common.ArrConfig{Host: a.Host, Name: a.Name, Token: a.Token})
-	}
-	config.Arrs = arrCfgs
-	common.JSONResponse(w, config, http.StatusOK)
-}

pkg/qbit/server/ui_routes.go

@@ -1,27 +0,0 @@
-package server
-
-import (
-	"github.com/go-chi/chi/v5"
-	"net/http"
-)
-
-func (u *uiHandler) Routes(r chi.Router) http.Handler {
-	r.Group(func(r chi.Router) {
-		r.Get("/", u.IndexHandler)
-		r.Get("/download", u.DownloadHandler)
-		r.Get("/repair", u.RepairHandler)
-		r.Get("/config", u.ConfigHandler)
-		r.Route("/internal", func(r chi.Router) {
-			r.Get("/arrs", u.handleGetArrs)
-			r.Post("/add", u.handleAddContent)
-			r.Get("/cached", u.handleCheckCached)
-			r.Post("/repair", u.handleRepairMedia)
-			r.Get("/torrents", u.handleGetTorrents)
-			r.Delete("/torrents/{hash}", u.handleDeleteTorrent)
-			r.Get("/config", u.handleGetConfig)
-			r.Get("/version", u.handleGetVersion)
-		})
-	})
-
-	return r
-}

pkg/qbit/shared/downloader.go

@@ -1,118 +0,0 @@
-package shared
-
-import (
-	"fmt"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/downloaders"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-func (q *QBit) processManualFiles(debridTorrent *debrid.Torrent) (string, error) {
-	q.logger.Info().Msgf("Downloading %d files...", len(debridTorrent.DownloadLinks))
-	torrentPath := common.RemoveExtension(debridTorrent.OriginalFilename)
-	parent := common.RemoveInvalidChars(filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentPath))
-	err := os.MkdirAll(parent, os.ModePerm)
-	if err != nil {
-		// add previous error to the error and return
-		return "", fmt.Errorf("failed to create directory: %s: %v", parent, err)
-	}
-	q.downloadFiles(debridTorrent, parent)
-	return torrentPath, nil
-}
-
-func (q *QBit) downloadFiles(debridTorrent *debrid.Torrent, parent string) {
-	var wg sync.WaitGroup
-	semaphore := make(chan struct{}, 5)
-	client := downloaders.GetHTTPClient()
-	for _, link := range debridTorrent.DownloadLinks {
-		if link.DownloadLink == "" {
-			q.logger.Info().Msgf("No download link found for %s", link.Filename)
-			continue
-		}
-		wg.Add(1)
-		semaphore <- struct{}{}
-		go func(link debrid.TorrentDownloadLinks) {
-			defer wg.Done()
-			defer func() { <-semaphore }()
-			err := downloaders.NormalHTTP(client, link.DownloadLink, filepath.Join(parent, link.Filename))
-			if err != nil {
-				q.logger.Info().Msgf("Error downloading %s: %v", link.DownloadLink, err)
-			} else {
-				q.logger.Info().Msgf("Downloaded %s successfully", link.DownloadLink)
-			}
-		}(link)
-	}
-	wg.Wait()
-	q.logger.Info().Msgf("Downloaded all files for %s", debridTorrent.Name)
-}
-
-func (q *QBit) ProcessSymlink(debridTorrent *debrid.Torrent) (string, error) {
-	var wg sync.WaitGroup
-	files := debridTorrent.Files
-	ready := make(chan debrid.TorrentFile, len(files))
-	if len(files) == 0 {
-		return "", fmt.Errorf("no video files found")
-	}
-	q.logger.Info().Msgf("Checking %d files...", len(files))
-	rCloneBase := debridTorrent.Debrid.GetMountPath()
-	torrentPath, err := q.getTorrentPath(rCloneBase, debridTorrent) // /MyTVShow/
-	if err != nil {
-		return "", fmt.Errorf("failed to get torrent path: %v", err)
-	}
-	// Fix for alldebrid
-	newTorrentPath := torrentPath
-	if newTorrentPath == "" {
-		// Alldebrid at times doesn't return the parent folder for single file torrents
-		newTorrentPath = common.RemoveExtension(debridTorrent.Name) // MyTVShow
-	}
-	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, newTorrentPath) // /mnt/symlinks/{category}/MyTVShow/
-	err = os.MkdirAll(torrentSymlinkPath, os.ModePerm)
-	if err != nil {
-		return "", fmt.Errorf("failed to create directory: %s: %v", torrentSymlinkPath, err)
-	}
-	torrentRclonePath := filepath.Join(rCloneBase, torrentPath) // leave it as is
-	q.logger.Debug().Msgf("Debrid torrent path: %s\nSymlink Path: %s", torrentRclonePath, torrentSymlinkPath)
-	for _, file := range files {
-		wg.Add(1)
-		go checkFileLoop(&wg, torrentRclonePath, file, ready)
-	}
-
-	go func() {
-		wg.Wait()
-		close(ready)
-	}()
-
-	for f := range ready {
-		q.logger.Info().Msgf("File is ready: %s", f.Path)
-		q.createSymLink(torrentSymlinkPath, torrentRclonePath, f)
-	}
-	return torrentPath, nil
-}
-
-func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debrid.Torrent) (string, error) {
-	for {
-		q.logger.Debug().Msgf("Checking for torrent path: %s", rclonePath)
-		torrentPath, err := debridTorrent.GetMountFolder(rclonePath)
-		if err == nil {
-			q.logger.Debug().Msgf("Found torrent path: %s", torrentPath)
-			return torrentPath, err
-		}
-		time.Sleep(time.Second)
-	}
-}
-
-func (q *QBit) createSymLink(path string, torrentMountPath string, file debrid.TorrentFile) {
-
-	// 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 {
-		q.logger.Info().Msgf("Failed to create symlink: %s: %v", fullPath, err)
-	}
-}

pkg/qbit/shared/utils.go

@@ -1,25 +0,0 @@
-package shared
-
-import (
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-func checkFileLoop(wg *sync.WaitGroup, dir string, file debrid.TorrentFile, ready chan<- debrid.TorrentFile) {
-	defer wg.Done()
-	ticker := time.NewTicker(1 * time.Second) // Check every second
-	defer ticker.Stop()
-	path := filepath.Join(dir, file.Path)
-	for {
-		select {
-		case <-ticker.C:
-			if common.FileReady(path) {
-				ready <- file
-				return
-			}
-		}
-	}
-}

pkg/qbit/storage.go

@@ -1,24 +1,33 @@
-package shared
+package qbit
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"sync"
 )
 
+func keyPair(hash, category string) string {
+	if category == "" {
+		category = "uncategorized"
+	}
+	return fmt.Sprintf("%s|%s", hash, category)
+}
+
+type Torrents = map[string]*Torrent
+
 type TorrentStorage struct {
-	torrents map[string]*Torrent
+	torrents Torrents
 	mu       sync.RWMutex
-	order    []string
 	filename string // Added to store the filename for persistence
 }
 
-func loadTorrentsFromJSON(filename string) (map[string]*Torrent, error) {
+func loadTorrentsFromJSON(filename string) (Torrents, error) {
 	data, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, err
 	}
-	torrents := make(map[string]*Torrent)
+	torrents := make(Torrents)
 	if err := json.Unmarshal(data, &torrents); err != nil {
 		return nil, err
 	}
@@ -29,16 +38,11 @@ func NewTorrentStorage(filename string) *TorrentStorage {
 	// Open the JSON file and read the data
 	torrents, err := loadTorrentsFromJSON(filename)
 	if err != nil {
-		torrents = make(map[string]*Torrent)
-	}
-	order := make([]string, 0, len(torrents))
-	for id := range torrents {
-		order = append(order, id)
+		torrents = make(Torrents)
 	}
 	// Create a new TorrentStorage
 	return &TorrentStorage{
 		torrents: torrents,
-		order:    order,
 		filename: filename,
 	}
 }
@@ -46,44 +50,37 @@ func NewTorrentStorage(filename string) *TorrentStorage {
 func (ts *TorrentStorage) Add(torrent *Torrent) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	ts.torrents[torrent.Hash] = torrent
-	ts.order = append(ts.order, torrent.Hash)
+	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
 	_ = ts.saveToFile()
 }
 
 func (ts *TorrentStorage) AddOrUpdate(torrent *Torrent) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	if _, exists := ts.torrents[torrent.Hash]; !exists {
-		ts.order = append(ts.order, torrent.Hash)
-	}
-	ts.torrents[torrent.Hash] = torrent
+	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
 	_ = ts.saveToFile()
 }
 
-func (ts *TorrentStorage) GetByID(id string) *Torrent {
+func (ts *TorrentStorage) Get(hash, category string) *Torrent {
 	ts.mu.RLock()
 	defer ts.mu.RUnlock()
-	for _, torrent := range ts.torrents {
-		if torrent.ID == id {
-			return torrent
+	torrent, exists := ts.torrents[keyPair(hash, category)]
+	if !exists && category == "" {
+		// Try to find the torrent without knowing the category
+		for _, t := range ts.torrents {
+			if t.Hash == hash {
+				return t
+			}
 		}
 	}
-	return nil
-}
-
-func (ts *TorrentStorage) Get(hash string) *Torrent {
-	ts.mu.RLock()
-	defer ts.mu.RUnlock()
-	return ts.torrents[hash]
+	return torrent
 }
 
 func (ts *TorrentStorage) GetAll(category string, filter string, hashes []string) []*Torrent {
 	ts.mu.RLock()
 	defer ts.mu.RUnlock()
 	torrents := make([]*Torrent, 0)
-	for _, id := range ts.order {
-		torrent := ts.torrents[id]
+	for _, torrent := range ts.torrents {
 		if category != "" && torrent.Category != category {
 			continue
 		}
@@ -92,14 +89,17 @@ func (ts *TorrentStorage) GetAll(category string, filter string, hashes []string
 		}
 		torrents = append(torrents, torrent)
 	}
+
 	if len(hashes) > 0 {
-		filtered := make([]*Torrent, 0, len(torrents))
+		filtered := make([]*Torrent, 0)
 		for _, hash := range hashes {
-			if torrent := ts.torrents[hash]; torrent != nil {
-				filtered = append(filtered, torrent)
+			for _, torrent := range torrents {
+				if torrent.Hash == hash {
+					filtered = append(filtered, torrent)
+				}
 			}
 		}
-		torrents = filtered
+		return filtered
 	}
 	return torrents
 }
@@ -107,24 +107,26 @@ func (ts *TorrentStorage) GetAll(category string, filter string, hashes []string
 func (ts *TorrentStorage) Update(torrent *Torrent) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	ts.torrents[torrent.Hash] = torrent
+	ts.torrents[keyPair(torrent.Hash, torrent.Category)] = torrent
 	_ = ts.saveToFile()
 }
 
-func (ts *TorrentStorage) Delete(hash string) {
+func (ts *TorrentStorage) Delete(hash, category string) {
 	ts.mu.Lock()
 	defer ts.mu.Unlock()
-	torrent, exists := ts.torrents[hash]
-	if !exists {
-		return
-	}
-	delete(ts.torrents, hash)
-	for i, id := range ts.order {
-		if id == hash {
-			ts.order = append(ts.order[:i], ts.order[i+1:]...)
-			break
+	key := keyPair(hash, category)
+	torrent, exists := ts.torrents[key]
+	if !exists && category == "" {
+		// Remove the torrent without knowing the category
+		for k, t := range ts.torrents {
+			if t.Hash == hash {
+				key = k
+				torrent = t
+				break
+			}
 		}
 	}
+	delete(ts.torrents, key)
 	// Delete the torrent folder
 	if torrent.ContentPath != "" {
 		err := os.RemoveAll(torrent.ContentPath)
@@ -135,6 +137,19 @@ func (ts *TorrentStorage) Delete(hash string) {
 	_ = ts.saveToFile()
 }
 
+func (ts *TorrentStorage) DeleteMultiple(hashes []string) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	for _, hash := range hashes {
+		for key, torrent := range ts.torrents {
+			if torrent.Hash == hash {
+				delete(ts.torrents, key)
+			}
+		}
+	}
+	_ = ts.saveToFile()
+}
+
 func (ts *TorrentStorage) Save() error {
 	ts.mu.RLock()
 	defer ts.mu.RUnlock()

pkg/qbit/torrent.go

@@ -1,13 +1,14 @@
-package shared
+package qbit
 
 import (
 	"cmp"
 	"context"
 	"fmt"
-	"github.com/google/uuid"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
 	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+	db "github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+	debrid "github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
 	"io"
 	"mime/multipart"
 	"os"
@@ -20,7 +21,7 @@ import (
 // All torrent related helpers goes here
 
 func (q *QBit) AddMagnet(ctx context.Context, url, category string) error {
-	magnet, err := common.GetMagnetFromUrl(url)
+	magnet, err := utils.GetMagnetFromUrl(url)
 	if err != nil {
 		return fmt.Errorf("error parsing magnet link: %w", err)
 	}
@@ -35,7 +36,7 @@ func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader,
 	file, _ := fileHeader.Open()
 	defer file.Close()
 	var reader io.Reader = file
-	magnet, err := common.GetMagnetFromFile(reader, fileHeader.Filename)
+	magnet, err := utils.GetMagnetFromFile(reader, fileHeader.Filename)
 	if err != nil {
 		return fmt.Errorf("error reading file: %s \n %w", fileHeader.Filename, err)
 	}
@@ -46,17 +47,19 @@ func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader,
 	return nil
 }
 
-func (q *QBit) Process(ctx context.Context, magnet *common.Magnet, category string) error {
-	torrent := q.CreateTorrentFromMagnet(magnet, category, "auto")
+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 := debrid.ProcessTorrent(q.Debrid, magnet, a, isSymlink)
+	debridTorrent, err := db.ProcessTorrent(svc.Debrid, magnet, a, isSymlink)
 	if err != nil || debridTorrent == nil {
 		if debridTorrent != nil {
-			go debridTorrent.Delete()
+			dbClient := service.GetDebrid().GetByName(debridTorrent.Debrid)
+			go dbClient.DeleteTorrent(debridTorrent)
 		}
 		if err == nil {
 			err = fmt.Errorf("failed to process torrent")
@@ -69,36 +72,16 @@ func (q *QBit) Process(ctx context.Context, magnet *common.Magnet, category stri
 	return nil
 }
 
-func (q *QBit) CreateTorrentFromMagnet(magnet *common.Magnet, category, source string) *Torrent {
-	torrent := &Torrent{
-		ID:        uuid.NewString(),
-		Hash:      strings.ToLower(magnet.InfoHash),
-		Name:      magnet.Name,
-		Size:      magnet.Size,
-		Category:  category,
-		Source:    source,
-		State:     "downloading",
-		MagnetUri: magnet.Link,
-
-		Tracker:    "udp://tracker.opentrackr.org:1337",
-		UpLimit:    -1,
-		DlLimit:    -1,
-		AutoTmm:    false,
-		Ratio:      1,
-		RatioLimit: 1,
-	}
-	return torrent
-}
-
 func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr *arr.Arr, isSymlink bool) {
+	debridClient := service.GetDebrid().GetByName(debridTorrent.Debrid)
 	for debridTorrent.Status != "downloaded" {
 		progress := debridTorrent.Progress
-		q.logger.Debug().Msgf("%s -> (%s) Download Progress: %.2f%%", debridTorrent.Debrid.GetName(), debridTorrent.Name, progress)
+		q.logger.Debug().Msgf("%s -> (%s) Download Progress: %.2f%%", debridTorrent.Debrid, debridTorrent.Name, progress)
 		time.Sleep(10 * time.Second)
-		dbT, err := debridTorrent.Debrid.CheckStatus(debridTorrent, isSymlink)
+		dbT, err := debridClient.CheckStatus(debridTorrent, isSymlink)
 		if err != nil {
 			q.logger.Error().Msgf("Error checking status: %v", err)
-			go debridTorrent.Delete()
+			go debridClient.DeleteTorrent(debridTorrent)
 			q.MarkAsFailed(torrent)
 			_ = arr.Refresh()
 			return
@@ -107,22 +90,22 @@ func (q *QBit) ProcessFiles(torrent *Torrent, debridTorrent *debrid.Torrent, arr
 		torrent = q.UpdateTorrentMin(torrent, debridTorrent)
 	}
 	var (
-		torrentPath string
-		err         error
+		torrentSymlinkPath string
+		err                error
 	)
 	debridTorrent.Arr = arr
 	if isSymlink {
-		torrentPath, err = q.ProcessSymlink(debridTorrent)
+		torrentSymlinkPath, err = q.ProcessSymlink(torrent) // /mnt/symlinks/{category}/MyTVShow/
 	} else {
-		torrentPath, err = q.processManualFiles(debridTorrent)
+		torrentSymlinkPath, err = q.ProcessManualFile(torrent)
 	}
 	if err != nil {
 		q.MarkAsFailed(torrent)
-		go debridTorrent.Delete()
+		go debridClient.DeleteTorrent(debridTorrent)
 		q.logger.Info().Msgf("Error: %v", err)
 		return
 	}
-	torrent.TorrentPath = filepath.Base(torrentPath)
+	torrent.TorrentPath = torrentSymlinkPath
 	q.UpdateTorrent(torrent, debridTorrent)
 	_ = arr.Refresh()
 }
@@ -147,19 +130,19 @@ func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torr
 	progress = progress / 100.0
 	sizeCompleted := int64(float64(totalSize) * progress)
 
-	var speed int
+	var speed int64
 	if debridTorrent.Speed != 0 {
 		speed = debridTorrent.Speed
 	}
 	var eta int
 	if speed != 0 {
-		eta = int(totalSize-sizeCompleted) / speed
+		eta = int((totalSize - sizeCompleted) / speed)
 	}
 	t.ID = debridTorrent.Id
 	t.Name = debridTorrent.Name
 	t.AddedOn = addedOn.Unix()
 	t.DebridTorrent = debridTorrent
-	t.Debrid = debridTorrent.Debrid.GetName()
+	t.Debrid = debridTorrent.Debrid
 	t.Size = totalSize
 	t.Completed = sizeCompleted
 	t.Downloaded = sizeCompleted
@@ -177,27 +160,19 @@ func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torr
 }
 
 func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
-	db := debridTorrent.Debrid
-	rcLoneMount := db.GetMountPath()
+	_db := service.GetDebrid().GetByName(debridTorrent.Debrid)
 	if debridTorrent == nil && t.ID != "" {
-		debridTorrent, _ = db.GetTorrent(t.ID)
+		debridTorrent, _ = _db.GetTorrent(t.ID)
 	}
 	if debridTorrent == nil {
-		q.logger.Info().Msgf("Torrent with ID %s not found in %s", t.ID, db.GetName())
+		q.logger.Info().Msgf("Torrent with ID %s not found in %s", t.ID, _db.GetName())
 		return t
 	}
 	if debridTorrent.Status != "downloaded" {
-		debridTorrent, _ = db.GetTorrent(t.ID)
+		debridTorrent, _ = _db.GetTorrent(t.ID)
 	}
-
-	if t.TorrentPath == "" {
-		tPath, _ := debridTorrent.GetMountFolder(rcLoneMount)
-		t.TorrentPath = filepath.Base(tPath)
-	}
-	savePath := filepath.Join(q.DownloadFolder, t.Category) + string(os.PathSeparator)
-	torrentPath := filepath.Join(savePath, t.TorrentPath) + string(os.PathSeparator)
 	t = q.UpdateTorrentMin(t, debridTorrent)
-	t.ContentPath = torrentPath
+	t.ContentPath = t.TorrentPath + string(os.PathSeparator)
 
 	if t.IsReady() {
 		t.State = "pausedUP"
@@ -296,8 +271,8 @@ func (q *QBit) SetTorrentTags(t *Torrent, tags []string) bool {
 
 func (q *QBit) RemoveTorrentTags(t *Torrent, tags []string) bool {
 	torrentTags := strings.Split(t.Tags, ",")
-	newTorrentTags := common.Remove(torrentTags, tags...)
-	q.Tags = common.Remove(q.Tags, tags...)
+	newTorrentTags := utils.RemoveItem(torrentTags, tags...)
+	q.Tags = utils.RemoveItem(q.Tags, tags...)
 	t.Tags = strings.Join(newTorrentTags, ",")
 	q.Storage.Update(t)
 	return true
@@ -316,6 +291,6 @@ func (q *QBit) AddTags(tags []string) bool {
 }
 
 func (q *QBit) RemoveTags(tags []string) bool {
-	q.Tags = common.Remove(q.Tags, tags...)
+	q.Tags = utils.RemoveItem(q.Tags, tags...)
 	return true
 }

pkg/qbit/types.go

@@ -1,6 +1,9 @@
-package shared
+package qbit
 
-import "github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+import (
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"sync"
+)
 
 type BuildInfo struct {
 	Libtorrent string `json:"libtorrent"`
@@ -169,10 +172,10 @@ type TorrentCategory struct {
 }
 
 type Torrent struct {
-	ID            string          `json:"-"`
-	DebridTorrent *debrid.Torrent `json:"-"`
-	Debrid        string          `json:"debrid"`
-	TorrentPath   string          `json:"-"`
+	ID            string           `json:"id"`
+	DebridTorrent *torrent.Torrent `json:"-"`
+	Debrid        string           `json:"debrid"`
+	TorrentPath   string           `json:"-"`
 
 	AddedOn           int64   `json:"added_on,omitempty"`
 	AmountLeft        int64   `json:"amount_left"`
@@ -183,7 +186,7 @@ type Torrent struct {
 	CompletionOn      int     `json:"completion_on,omitempty"`
 	ContentPath       string  `json:"content_path"`
 	DlLimit           int     `json:"dl_limit"`
-	Dlspeed           int     `json:"dlspeed"`
+	Dlspeed           int64   `json:"dlspeed"`
 	Downloaded        int64   `json:"downloaded"`
 	DownloadedSession int64   `json:"downloaded_session"`
 	Eta               int     `json:"eta"`
@@ -217,8 +220,10 @@ type Torrent struct {
 	UpLimit           int64   `json:"up_limit,omitempty"`
 	Uploaded          int64   `json:"uploaded,omitempty"`
 	UploadedSession   int64   `json:"uploaded_session,omitempty"`
-	Upspeed           int     `json:"upspeed,omitempty"`
+	Upspeed           int64   `json:"upspeed,omitempty"`
 	Source            string  `json:"source,omitempty"`
+
+	Mu sync.Mutex `json:"-"`
 }
 
 func (t *Torrent) IsReady() bool {
@@ -232,7 +237,7 @@ type TorrentProperties struct {
 	CreatedBy              string `json:"created_by,omitempty"`
 	CreationDate           int64  `json:"creation_date,omitempty"`
 	DlLimit                int    `json:"dl_limit,omitempty"`
-	DlSpeed                int    `json:"dl_speed,omitempty"`
+	DlSpeed                int64  `json:"dl_speed,omitempty"`
 	DlSpeedAvg             int    `json:"dl_speed_avg,omitempty"`
 	Eta                    int    `json:"eta,omitempty"`
 	LastSeen               int64  `json:"last_seen,omitempty"`
@@ -257,7 +262,7 @@ type TorrentProperties struct {
 	TotalUploadedSession   int64  `json:"total_uploaded_session,omitempty"`
 	TotalWasted            int64  `json:"total_wasted,omitempty"`
 	UpLimit                int    `json:"up_limit,omitempty"`
-	UpSpeed                int    `json:"up_speed,omitempty"`
+	UpSpeed                int64  `json:"up_speed,omitempty"`
 	UpSpeedAvg             int    `json:"up_speed_avg,omitempty"`
 }
 

pkg/qbit/worker.go

@@ -1,7 +1,8 @@
-package shared
+package qbit
 
 import (
 	"context"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
 	"time"
 )
 
@@ -28,7 +29,8 @@ func (q *QBit) StartRefreshWorker(ctx context.Context) {
 }
 
 func (q *QBit) RefreshArrs() {
-	for _, arr := range q.Arrs.GetAll() {
+	arrs := service.GetService().Arr
+	for _, arr := range arrs.GetAll() {
 		err := arr.Refresh()
 		if err != nil {
 			return

pkg/rclone/rclone.go

@@ -0,0 +1,283 @@
+package rclone
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/pkg/webdav"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+type Remote struct {
+	Type       string            `json:"type"`
+	Name       string            `json:"name"`
+	Url        string            `json:"url"`
+	MountPoint string            `json:"mount_point"`
+	Flags      map[string]string `json:"flags"`
+}
+
+func (rc *Rclone) Config() string {
+	var content string
+
+	for _, remote := range rc.Remotes {
+		content += fmt.Sprintf("[%s]\n", remote.Name)
+		content += fmt.Sprintf("type = %s\n", remote.Type)
+		content += fmt.Sprintf("url = %s\n", remote.Url)
+		content += fmt.Sprintf("vendor = other\n")
+
+		for key, value := range remote.Flags {
+			content += fmt.Sprintf("%s = %s\n", key, value)
+		}
+		content += "\n\n"
+	}
+
+	return content
+}
+
+type Rclone struct {
+	Remotes    map[string]Remote `json:"remotes"`
+	logger     zerolog.Logger
+	cmd        *exec.Cmd
+	configPath string
+}
+
+func New(webdav *webdav.WebDav) (*Rclone, error) {
+	// Check if rclone is installed
+	cfg := config.GetConfig()
+	configPath := fmt.Sprintf("%s/rclone.conf", cfg.Path)
+
+	if _, err := exec.LookPath("rclone"); err != nil {
+		return nil, fmt.Errorf("rclone is not installed: %w", err)
+	}
+	remotes := make(map[string]Remote)
+	for _, handler := range webdav.Handlers {
+		url := fmt.Sprintf("http://localhost:%s/webdav/%s/", cfg.QBitTorrent.Port, strings.ToLower(handler.Name))
+		rmt := Remote{
+			Type:       "webdav",
+			Name:       handler.Name,
+			Url:        url,
+			MountPoint: filepath.Join("/mnt/rclone/", handler.Name),
+			Flags:      map[string]string{},
+		}
+		remotes[handler.Name] = rmt
+	}
+
+	rc := &Rclone{
+		logger:     logger.NewLogger("rclone", "info", os.Stdout),
+		Remotes:    remotes,
+		configPath: configPath,
+	}
+	if err := rc.WriteConfig(); err != nil {
+		return nil, err
+	}
+	return rc, nil
+}
+
+func (rc *Rclone) WriteConfig() error {
+
+	// Create config directory if it doesn't exist
+	configDir := filepath.Dir(rc.configPath)
+	if err := os.MkdirAll(configDir, 0755); err != nil {
+		return fmt.Errorf("failed to create config directory: %w", err)
+	}
+
+	// Write the config file
+	if err := os.WriteFile(rc.configPath, []byte(rc.Config()), 0600); err != nil {
+		return fmt.Errorf("failed to write config file: %w", err)
+	}
+
+	rc.logger.Info().Msgf("Wrote rclone config with %d remotes to %s", len(rc.Remotes), rc.configPath)
+	return nil
+}
+
+func (rc *Rclone) Start(ctx context.Context) error {
+	var wg sync.WaitGroup
+	errChan := make(chan error)
+	for _, remote := range rc.Remotes {
+		wg.Add(1)
+		go func(remote Remote) {
+			defer wg.Done()
+			if err := rc.Mount(ctx, &remote); err != nil {
+				rc.logger.Error().Err(err).Msgf("failed to mount %s", remote.Name)
+				select {
+				case errChan <- err:
+				default:
+				}
+			}
+		}(remote)
+	}
+	return <-errChan
+}
+
+func (rc *Rclone) testConnection(ctx context.Context, remote *Remote) error {
+	testArgs := []string{
+		"ls",
+		"--config", rc.configPath,
+		"--log-level", "DEBUG",
+		remote.Name + ":",
+	}
+
+	cmd := exec.CommandContext(ctx, "rclone", testArgs...)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		rc.logger.Error().Err(err).Str("output", string(output)).Msg("Connection test failed")
+		return fmt.Errorf("connection test failed: %w", err)
+	}
+
+	rc.logger.Info().Msg("Connection test successful")
+	return nil
+}
+
+func (rc *Rclone) Mount(ctx context.Context, remote *Remote) error {
+	// Ensure the mount point directory exists
+	if err := os.MkdirAll(remote.MountPoint, 0755); err != nil {
+		rc.logger.Info().Err(err).Msgf("failed to create mount point directory: %s", remote.MountPoint)
+		return err
+	}
+
+	//if err := rc.testConnection(ctx, remote); err != nil {
+	//	return err
+	//}
+
+	// Basic arguments
+	args := []string{
+		"mount",
+		remote.Name + ":",
+		remote.MountPoint,
+		"--config", rc.configPath,
+		"--vfs-cache-mode", "full",
+		"--log-level", "DEBUG", // Keep this, remove -vv
+		"--allow-other",         // Keep this
+		"--allow-root",          // Add this
+		"--default-permissions", // Add this
+		"--vfs-cache-max-age", "24h",
+		"--timeout", "1m",
+		"--transfers", "4",
+		"--buffer-size", "32M",
+	}
+
+	// Add any additional flags
+	for key, value := range remote.Flags {
+		args = append(args, "--"+key, value)
+	}
+
+	// Create command
+	rc.cmd = exec.CommandContext(ctx, "rclone", args...)
+
+	// Set up pipes for stdout and stderr
+	stdout, err := rc.cmd.StdoutPipe()
+	if err != nil {
+		return err
+	}
+
+	stderr, err := rc.cmd.StderrPipe()
+	if err != nil {
+		return err
+	}
+
+	// Start the command
+	if err := rc.cmd.Start(); err != nil {
+		return err
+	}
+
+	// Channel to signal mount success
+	mountReady := make(chan bool)
+	mountError := make(chan error)
+
+	// Monitor stdout
+	go func() {
+		scanner := bufio.NewScanner(stdout)
+		for scanner.Scan() {
+			text := scanner.Text()
+			rc.logger.Info().Msg("stdout: " + text)
+			if strings.Contains(text, "Mount succeeded") {
+				mountReady <- true
+				return
+			}
+		}
+	}()
+
+	// Monitor stderr
+	go func() {
+		scanner := bufio.NewScanner(stderr)
+		for scanner.Scan() {
+			text := scanner.Text()
+			rc.logger.Info().Msg("stderr: " + text)
+			if strings.Contains(text, "error") {
+				mountError <- fmt.Errorf("mount error: %s", text)
+				return
+			}
+		}
+	}()
+
+	// Wait for mount with timeout
+	select {
+	case <-mountReady:
+		rc.logger.Info().Msgf("Successfully mounted %s at %s", remote.Name, remote.MountPoint)
+		return nil
+	case err := <-mountError:
+		err = rc.cmd.Process.Kill()
+		if err != nil {
+			return err
+		}
+		return err
+	case <-ctx.Done():
+		err := rc.cmd.Process.Kill()
+		if err != nil {
+			return err
+		}
+		return ctx.Err()
+	case <-time.After(30 * time.Second):
+		err := rc.cmd.Process.Kill()
+		if err != nil {
+			return err
+		}
+		return fmt.Errorf("mount timeout after 30 seconds")
+	}
+}
+
+func (rc *Rclone) Unmount(ctx context.Context, remote *Remote) error {
+	if rc.cmd != nil && rc.cmd.Process != nil {
+		// First try graceful shutdown
+		if err := rc.cmd.Process.Signal(os.Interrupt); err != nil {
+			rc.logger.Warn().Err(err).Msg("failed to send interrupt signal")
+		}
+
+		// Wait for a bit to allow graceful shutdown
+		done := make(chan error)
+		go func() {
+			done <- rc.cmd.Wait()
+		}()
+
+		select {
+		case err := <-done:
+			if err != nil {
+				rc.logger.Warn().Err(err).Msg("process exited with error")
+			}
+		case <-time.After(5 * time.Second):
+			// Force kill if it doesn't shut down gracefully
+			if err := rc.cmd.Process.Kill(); err != nil {
+				rc.logger.Error().Err(err).Msg("failed to kill process")
+				return err
+			}
+		}
+	}
+
+	// Use fusermount to ensure the mountpoint is unmounted
+	cmd := exec.CommandContext(ctx, "fusermount", "-u", remote.MountPoint)
+	if err := cmd.Run(); err != nil {
+		rc.logger.Warn().Err(err).Msg("fusermount unmount failed")
+		// Don't return error here as the process might already be dead
+	}
+
+	rc.logger.Info().Msgf("Successfully unmounted %s", remote.MountPoint)
+	return nil
+}

pkg/repair/misc.go

@@ -2,6 +2,8 @@ package repair
 
 import (
 	"fmt"
+	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"time"
@@ -68,3 +70,62 @@ func parseDurationInterval(interval string) (time.Duration, error) {
 		return 0, fmt.Errorf("invalid unit in interval: %c", unit)
 	}
 }
+
+func fileIsSymlinked(file string) bool {
+	info, err := os.Lstat(file)
+	if err != nil {
+		return false
+	}
+	return info.Mode()&os.ModeSymlink != 0
+}
+
+func getSymlinkTarget(file string) string {
+	if fileIsSymlinked(file) {
+		target, err := os.Readlink(file)
+		if err != nil {
+			return ""
+		}
+		if !filepath.IsAbs(target) {
+			dir := filepath.Dir(file)
+			target = filepath.Join(dir, target)
+		}
+		return target
+	}
+	return ""
+}
+
+func fileIsReadable(filePath string) error {
+	// First check if file exists and is accessible
+	info, err := os.Stat(filePath)
+	if err != nil {
+		return err
+	}
+
+	// Check if it's a regular file
+	if !info.Mode().IsRegular() {
+		return fmt.Errorf("not a regular file")
+	}
+
+	// Try to read the first 1024 bytes
+	err = checkFileStart(filePath)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func checkFileStart(filePath string) error {
+	f, err := os.Open(filePath)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	// Read first 1kb
+	buffer := make([]byte, 1024)
+	_, err = f.Read(buffer)
+	if err != nil {
+		return err
+	}
+	return nil
+}

pkg/repair/repair.go

@@ -2,71 +2,351 @@ package repair
 
 import (
 	"context"
-	"github.com/sirrobot01/debrid-blackhole/common"
+	"fmt"
+	"github.com/google/uuid"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
 	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/engine"
 	"log"
+	"net/http"
+	"net/url"
 	"os"
 	"os/signal"
+	"path/filepath"
+	"runtime"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 )
 
-func Start(ctx context.Context, config *common.Config, arrs *arr.Storage) error {
-	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
-	logger := common.NewLogger("Repair", config.LogLevel, os.Stdout)
-	defer stop()
+type Repair struct {
+	Jobs       []Job `json:"jobs"`
+	arrs       *arr.Storage
+	deb        engine.Service
+	duration   time.Duration
+	runOnStart bool
+	ZurgURL    string
+	IsZurg     bool
+	logger     zerolog.Logger
+}
 
-	duration, err := parseSchedule(config.Repair.Interval)
+func New(deb *engine.Engine, arrs *arr.Storage) *Repair {
+	cfg := config.GetConfig()
+	duration, err := parseSchedule(cfg.Repair.Interval)
 	if err != nil {
-		log.Fatalf("Failed to parse schedule: %v", err)
+		duration = time.Hour * 24
+	}
+	r := &Repair{
+		arrs:       arrs,
+		deb:        deb.Get(),
+		logger:     logger.NewLogger("repair", cfg.LogLevel, os.Stdout),
+		duration:   duration,
+		runOnStart: cfg.Repair.RunOnStart,
+		ZurgURL:    cfg.Repair.ZurgURL,
+	}
+	if r.ZurgURL != "" {
+		r.IsZurg = true
+	}
+	return r
+}
+
+type Job struct {
+	ID          string     `json:"id"`
+	Arrs        []*arr.Arr `json:"arrs"`
+	MediaIDs    []string   `json:"media_ids"`
+	StartedAt   time.Time  `json:"created_at"`
+	CompletedAt time.Time  `json:"finished_at"`
+	FailedAt    time.Time  `json:"failed_at"`
+
+	Error string `json:"error"`
+}
+
+func (r *Repair) NewJob(arrs []*arr.Arr, mediaIDs []string) *Job {
+	return &Job{
+		ID:        uuid.New().String(),
+		Arrs:      arrs,
+		MediaIDs:  mediaIDs,
+		StartedAt: time.Now(),
+	}
+}
+
+func (r *Repair) PreRunChecks() error {
+	// Check if zurg url is reachable
+	if !r.IsZurg {
+		return nil
+	}
+	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)
+		return err
+	}
+	if resp.StatusCode != http.StatusOK {
+		r.logger.Debug().Msgf("Precheck failed: Zurg returned %d", resp.StatusCode)
+		return err
+	}
+	return nil
+}
+
+func (r *Repair) Repair(arrs []*arr.Arr, mediaIds []string) error {
+
+	j := r.NewJob(arrs, mediaIds)
+
+	if err := r.PreRunChecks(); err != nil {
+		return err
+	}
+	var wg sync.WaitGroup
+	errors := make(chan error)
+	for _, a := range j.Arrs {
+		wg.Add(1)
+		go func(a *arr.Arr) {
+			defer wg.Done()
+			if len(j.MediaIDs) == 0 {
+				if err := r.RepairArr(a, ""); err != nil {
+					log.Printf("Error repairing %s: %v", a.Name, err)
+					errors <- err
+				}
+			} else {
+				for _, id := range j.MediaIDs {
+					if err := r.RepairArr(a, id); err != nil {
+						log.Printf("Error repairing %s: %v", a.Name, err)
+						errors <- err
+					}
+				}
+			}
+		}(a)
+	}
+	wg.Wait()
+	close(errors)
+	err := <-errors
+	if err != nil {
+		j.FailedAt = time.Now()
+		j.Error = err.Error()
+		return err
+	}
+	j.CompletedAt = time.Now()
+	return nil
+}
+
+func (r *Repair) Start(ctx context.Context) error {
+	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	cfg := config.GetConfig()
+
+	if r.runOnStart {
+		r.logger.Info().Msgf("Running initial repair")
+		go func() {
+			if err := r.Repair(r.arrs.GetAll(), []string{}); err != nil {
+				r.logger.Info().Msgf("Error during initial repair: %v", err)
+			}
+		}()
 	}
 
-	if config.Repair.RunOnStart {
-		logger.Info().Msgf("Running initial repair")
-		if err := repair(arrs); err != nil {
-			log.Printf("Error during initial repair: %v", err)
-			return err
-		}
-	}
-
-	ticker := time.NewTicker(duration)
+	ticker := time.NewTicker(r.duration)
 	defer ticker.Stop()
 
-	if strings.Contains(config.Repair.Interval, ":") {
-		logger.Info().Msgf("Starting repair worker, scheduled daily at %s", config.Repair.Interval)
-	} else {
-		logger.Info().Msgf("Starting repair worker with %v interval", duration)
-	}
+	r.logger.Info().Msgf("Starting repair worker with %v interval", r.duration)
 
 	for {
 		select {
 		case <-ctx.Done():
-			logger.Info().Msg("Repair worker stopped")
+			r.logger.Info().Msg("Repair worker stopped")
 			return nil
 		case t := <-ticker.C:
-			logger.Info().Msgf("Running repair at %v", t.Format("15:04:05"))
-			if err := repair(arrs); err != nil {
-				logger.Info().Msgf("Error during repair: %v", err)
-				return err
+			r.logger.Info().Msgf("Running repair at %v", t.Format("15:04:05"))
+			err := r.Repair(r.arrs.GetAll(), []string{})
+			if err != nil {
+				r.logger.Info().Msgf("Error during repair: %v", err)
 			}
 
 			// If using time-of-day schedule, reset the ticker for next day
-			if strings.Contains(config.Repair.Interval, ":") {
-				nextDuration, err := parseSchedule(config.Repair.Interval)
-				if err != nil {
-					logger.Info().Msgf("Error calculating next schedule: %v", err)
-					return err
-				}
-				ticker.Reset(nextDuration)
+			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"))
 		}
 	}
 }
 
-func repair(arrs *arr.Storage) error {
-	for _, a := range arrs.GetAll() {
-		go a.Repair("")
+func (r *Repair) RepairArr(a *arr.Arr, tmdbId string) error {
+
+	cfg := config.GetConfig()
+
+	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.Type, err)
+		return err
 	}
+	r.logger.Info().Msgf("Found %d %s media", len(media), a.Type)
+
+	if len(media) == 0 {
+		r.logger.Info().Msgf("No %s media found", a.Type)
+		return 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 nil
+	}
+
+	semaphore := make(chan struct{}, runtime.NumCPU()*4)
+	totalBrokenItems := 0
+	var wg sync.WaitGroup
+	for _, m := range media {
+		wg.Add(1)
+		semaphore <- struct{}{}
+		go func(m arr.Content) {
+			defer wg.Done()
+			defer func() { <-semaphore }()
+			brokenItems := r.getBrokenFiles(m)
+			if brokenItems != nil {
+				r.logger.Debug().Msgf("Found %d broken files for %s", len(brokenItems), m.Title)
+				if !cfg.Repair.SkipDeletion {
+					if err := a.DeleteFiles(brokenItems); err != nil {
+						r.logger.Info().Msgf("Failed to delete broken items for %s: %v", m.Title, err)
+					}
+				}
+				if err := a.SearchMissing(brokenItems); err != nil {
+					r.logger.Info().Msgf("Failed to search missing items for %s: %v", m.Title, err)
+				}
+				totalBrokenItems += len(brokenItems)
+			}
+		}(m)
+	}
+	wg.Wait()
+	r.logger.Info().Msgf("Repair completed for %s. %d broken items found", a.Name, totalBrokenItems)
 	return 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) {
+		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
+		}
+	}
+	return true
+}
+
+func (r *Repair) getBrokenFiles(media arr.Content) []arr.ContentFile {
+
+	if r.IsZurg {
+		return r.getZurgBrokenFiles(media)
+	} else {
+		return r.getFileBrokenFiles(media)
+	}
+}
+
+func (r *Repair) getFileBrokenFiles(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 := make(map[string][]arr.ContentFile)
+	files := media.Files
+	for _, file := range files {
+		target := getSymlinkTarget(file.Path)
+		if target != "" {
+			file.IsSymlink = true
+			dir, _ := filepath.Split(target)
+			parent := filepath.Base(filepath.Clean(dir))
+			uniqueParents[parent] = append(uniqueParents[parent], file)
+		}
+	}
+
+	for parent, f := 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
+		}
+	}
+	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)
+	return brokenFiles
+}
+
+func (r *Repair) getZurgBrokenFiles(media arr.Content) []arr.ContentFile {
+	// Use zurg setup to check file availability with zurg
+	// This reduces bandwidth usage significantly
+
+	brokenFiles := make([]arr.ContentFile, 0)
+	uniqueParents := make(map[string][]arr.ContentFile)
+	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] = append(uniqueParents[parent], file)
+		}
+	}
+	// Access zurg url + symlink folder + first file(encoded)
+	for parent, f := range uniqueParents {
+		r.logger.Debug().Msgf("Checking %s", parent)
+		encodedParent := url.PathEscape(parent)
+		encodedFile := url.PathEscape(f[0].TargetPath)
+		fullURL := fmt.Sprintf("%s/http/__all__/%s/%s", r.ZurgURL, encodedParent, 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...)
+			continue
+		}
+
+		resp, err := http.Get(fullURL)
+		if err != nil {
+			r.logger.Debug().Err(err).Msgf("Failed to reach %s", fullURL)
+			brokenFiles = append(brokenFiles, f...)
+			continue
+		}
+		resp.Body.Close()
+		if resp.StatusCode != http.StatusOK {
+			r.logger.Debug().Msgf("Failed to get download url for %s", fullURL)
+			brokenFiles = append(brokenFiles, f...)
+			continue
+		}
+		downloadUrl := resp.Request.URL.String()
+		if downloadUrl != "" {
+			r.logger.Debug().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 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)
+	return brokenFiles
+}

pkg/server/server.go

@@ -7,10 +7,8 @@ import (
 	"github.com/go-chi/chi/v5"
 	"github.com/go-chi/chi/v5/middleware"
 	"github.com/rs/zerolog"
-	"github.com/sirrobot01/debrid-blackhole/common"
-	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
-	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
-	"github.com/sirrobot01/debrid-blackhole/pkg/qbit/shared"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
 	"io"
 	"net/http"
 	"os"
@@ -19,40 +17,32 @@ import (
 )
 
 type Server struct {
-	qbit   *shared.QBit
+	router *chi.Mux
 	logger zerolog.Logger
 }
 
-func NewServer(config *common.Config, deb *debrid.DebridService, arrs *arr.Storage) *Server {
-	logger := common.NewLogger("QBit", config.QBitTorrent.LogLevel, os.Stdout)
-	q := shared.NewQBit(config, deb, logger, arrs)
+func New() *Server {
+	cfg := config.GetConfig()
+	l := logger.NewLogger("http", cfg.QBitTorrent.LogLevel, os.Stdout)
+	r := chi.NewRouter()
+	r.Use(middleware.Recoverer)
+	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
+
 	return &Server{
-		qbit:   q,
-		logger: logger,
+		router: r,
+		logger: l,
 	}
 }
 
 func (s *Server) Start(ctx context.Context) error {
-	r := chi.NewRouter()
-	r.Use(middleware.Recoverer)
-	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
-	logLevel := s.logger.GetLevel().String()
-	debug := logLevel == "debug"
-	q := qbitHandler{qbit: s.qbit, logger: s.logger, debug: debug}
-	ui := uiHandler{qbit: s.qbit, logger: common.NewLogger("UI", s.logger.GetLevel().String(), os.Stdout), debug: debug}
-
+	cfg := config.GetConfig()
 	// Register routes
-	r.Get("/logs", s.GetLogs)
-	q.Routes(r)
-	ui.Routes(r)
-
-	go s.qbit.StartWorker(context.Background())
-
-	s.logger.Info().Msgf("Starting QBit server on :%s", s.qbit.Port)
-	port := fmt.Sprintf(":%s", s.qbit.Port)
+	s.router.Get("/logs", s.getLogs)
+	port := fmt.Sprintf(":%s", cfg.QBitTorrent.Port)
+	s.logger.Info().Msgf("Starting server on %s", port)
 	srv := &http.Server{
 		Addr:    port,
-		Handler: r,
+		Handler: s.router,
 	}
 
 	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
@@ -70,8 +60,16 @@ func (s *Server) Start(ctx context.Context) error {
 	return srv.Shutdown(context.Background())
 }
 
-func (s *Server) GetLogs(w http.ResponseWriter, r *http.Request) {
-	logFile := common.GetLogPath()
+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()
 
 	// Open and read the file
 	file, err := os.Open(logFile)
@@ -79,7 +77,12 @@ func (s *Server) GetLogs(w http.ResponseWriter, r *http.Request) {
 		http.Error(w, "Error reading log file", http.StatusInternalServerError)
 		return
 	}
-	defer file.Close()
+	defer func(file *os.File) {
+		err := file.Close()
+		if err != nil {
+			s.logger.Debug().Err(err).Msg("Error closing log file")
+		}
+	}(file)
 
 	// Set headers
 	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
@@ -91,6 +94,7 @@ func (s *Server) GetLogs(w http.ResponseWriter, r *http.Request) {
 	// Stream the file
 	_, err = io.Copy(w, file)
 	if err != nil {
+		s.logger.Debug().Err(err).Msg("Error streaming log file")
 		http.Error(w, "Error streaming log file", http.StatusInternalServerError)
 		return
 	}

pkg/service/service.go

@@ -0,0 +1,56 @@
+package service
+
+import (
+	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/engine"
+	"github.com/sirrobot01/debrid-blackhole/pkg/repair"
+	"sync"
+)
+
+type Service struct {
+	Repair *repair.Repair
+	Arr    *arr.Storage
+	Debrid *engine.Engine
+}
+
+var (
+	instance *Service
+	once     sync.Once
+)
+
+func New() *Service {
+	once.Do(func() {
+		arrs := arr.NewStorage()
+		deb := debrid.New()
+		instance = &Service{
+			Repair: repair.New(deb, arrs),
+			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.New()
+	instance = &Service{
+		Repair: repair.New(deb, arrs),
+		Arr:    arrs,
+		Debrid: deb,
+	}
+	return instance
+}
+
+func GetDebrid() *engine.Engine {
+	return GetService().Debrid
+}

pkg/version/version.go

@@ -1,10 +1,16 @@
 package version
 
+import "fmt"
+
 type Info struct {
 	Version string `json:"version"`
 	Channel string `json:"channel"`
 }
 
+func (i Info) String() string {
+	return fmt.Sprintf("%s-%s", i.Version, i.Channel)
+}
+
 var (
 	Version = ""
 	Channel = ""

pkg/web/routes.go

@@ -0,0 +1,35 @@
+package web
+
+import (
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+func (ui *Handler) Routes() http.Handler {
+	r := chi.NewRouter()
+
+	r.Get("/login", ui.LoginHandler)
+	r.Post("/login", ui.LoginHandler)
+	r.Get("/setup", ui.SetupHandler)
+	r.Post("/setup", ui.SetupHandler)
+
+	r.Group(func(r chi.Router) {
+		r.Use(ui.authMiddleware)
+		r.Get("/", ui.IndexHandler)
+		r.Get("/download", ui.DownloadHandler)
+		r.Get("/repair", ui.RepairHandler)
+		r.Get("/config", ui.ConfigHandler)
+		r.Route("/internal", func(r chi.Router) {
+			r.Get("/arrs", ui.handleGetArrs)
+			r.Post("/add", ui.handleAddContent)
+			r.Post("/repair", ui.handleRepairMedia)
+			r.Get("/torrents", ui.handleGetTorrents)
+			r.Delete("/torrents/{category}/{hash}", ui.handleDeleteTorrent)
+			r.Delete("/torrents/", ui.handleDeleteTorrents)
+			r.Get("/config", ui.handleGetConfig)
+			r.Get("/version", ui.handleGetVersion)
+		})
+	})
+
+	return r
+}

pkg/web/ui.go

@@ -0,0 +1,443 @@
+package web
+
+import (
+	"embed"
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/sessions"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/internal/request"
+	"github.com/sirrobot01/debrid-blackhole/internal/utils"
+	"github.com/sirrobot01/debrid-blackhole/pkg/qbit"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
+	"golang.org/x/crypto/bcrypt"
+	"html/template"
+	"net/http"
+	"os"
+	"strings"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
+	"github.com/sirrobot01/debrid-blackhole/pkg/version"
+)
+
+type AddRequest struct {
+	Url        string   `json:"url"`
+	Arr        string   `json:"arr"`
+	File       string   `json:"file"`
+	NotSymlink bool     `json:"notSymlink"`
+	Content    string   `json:"content"`
+	Seasons    []string `json:"seasons"`
+	Episodes   []string `json:"episodes"`
+}
+
+type ArrResponse struct {
+	Name string `json:"name"`
+	Url  string `json:"url"`
+}
+
+type ContentResponse struct {
+	ID    string `json:"id"`
+	Title string `json:"title"`
+	Type  string `json:"type"`
+	ArrID string `json:"arr"`
+}
+
+type RepairRequest struct {
+	ArrName  string   `json:"arr"`
+	MediaIds []string `json:"mediaIds"`
+	Async    bool     `json:"async"`
+}
+
+//go:embed web/*
+var content embed.FS
+
+type Handler struct {
+	qbit   *qbit.QBit
+	logger zerolog.Logger
+}
+
+func New(qbit *qbit.QBit) *Handler {
+	cfg := config.GetConfig()
+	return &Handler{
+		qbit:   qbit,
+		logger: logger.NewLogger("ui", cfg.LogLevel, os.Stdout),
+	}
+}
+
+var (
+	store     = sessions.NewCookieStore([]byte("your-secret-key")) // Change this to a secure key
+	templates *template.Template
+)
+
+func init() {
+	templates = template.Must(template.ParseFS(
+		content,
+		"web/layout.html",
+		"web/index.html",
+		"web/download.html",
+		"web/repair.html",
+		"web/config.html",
+		"web/login.html",
+		"web/setup.html",
+	))
+
+	store.Options = &sessions.Options{
+		Path:     "/",
+		MaxAge:   86400 * 7,
+		HttpOnly: false,
+	}
+}
+
+func (ui *Handler) authMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Check if setup is needed
+		cfg := config.GetConfig()
+		if cfg.NeedsSetup() && r.URL.Path != "/setup" {
+			http.Redirect(w, r, "/setup", http.StatusSeeOther)
+			return
+		}
+
+		if !cfg.UseAuth {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		// Skip auth check for setup page
+		if r.URL.Path == "/setup" {
+			next.ServeHTTP(w, r)
+			return
+		}
+
+		session, _ := store.Get(r, "auth-session")
+		auth, ok := session.Values["authenticated"].(bool)
+
+		if !ok || !auth {
+			http.Redirect(w, r, "/login", http.StatusSeeOther)
+			return
+		}
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (ui *Handler) verifyAuth(username, password string) bool {
+	// If you're storing hashed password, use bcrypt to compare
+	if username == "" {
+		return false
+	}
+	auth := config.GetConfig().GetAuth()
+	if auth == nil {
+		return false
+	}
+	if username != auth.Username {
+		return false
+	}
+	err := bcrypt.CompareHashAndPassword([]byte(auth.Password), []byte(password))
+	return err == nil
+}
+
+func (ui *Handler) LoginHandler(w http.ResponseWriter, r *http.Request) {
+	if r.Method == "GET" {
+		data := map[string]interface{}{
+			"Page":  "login",
+			"Title": "Login",
+		}
+		if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	var credentials struct {
+		Username string `json:"username"`
+		Password string `json:"password"`
+	}
+
+	if err := json.NewDecoder(r.Body).Decode(&credentials); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	if ui.verifyAuth(credentials.Username, credentials.Password) {
+		session, _ := store.Get(r, "auth-session")
+		session.Values["authenticated"] = true
+		session.Values["username"] = credentials.Username
+		if err := session.Save(r, w); err != nil {
+			http.Error(w, "Error saving session", http.StatusInternalServerError)
+			return
+		}
+		http.Redirect(w, r, "/", http.StatusSeeOther)
+		return
+	}
+
+	http.Error(w, "Invalid credentials", http.StatusUnauthorized)
+}
+
+func (ui *Handler) LogoutHandler(w http.ResponseWriter, r *http.Request) {
+	session, _ := store.Get(r, "auth-session")
+	session.Values["authenticated"] = false
+	session.Options.MaxAge = -1
+	err := session.Save(r, w)
+	if err != nil {
+		return
+	}
+	http.Redirect(w, r, "/login", http.StatusSeeOther)
+}
+
+func (ui *Handler) SetupHandler(w http.ResponseWriter, r *http.Request) {
+	cfg := config.GetConfig()
+	authCfg := cfg.GetAuth()
+
+	if !cfg.NeedsSetup() {
+		http.Redirect(w, r, "/", http.StatusSeeOther)
+		return
+	}
+
+	if r.Method == "GET" {
+		data := map[string]interface{}{
+			"Page":  "setup",
+			"Title": "Setup",
+		}
+		if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+		}
+		return
+	}
+
+	// Handle POST (setup attempt)
+	username := r.FormValue("username")
+	password := r.FormValue("password")
+	confirmPassword := r.FormValue("confirmPassword")
+
+	if password != confirmPassword {
+		http.Error(w, "Passwords do not match", http.StatusBadRequest)
+		return
+	}
+
+	// Hash the password
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		http.Error(w, "Error processing password", http.StatusInternalServerError)
+		return
+	}
+
+	// Set the credentials
+	authCfg.Username = username
+	authCfg.Password = string(hashedPassword)
+
+	if err := cfg.SaveAuth(authCfg); err != nil {
+		http.Error(w, "Error saving credentials", http.StatusInternalServerError)
+		return
+	}
+
+	// Create a session
+	session, _ := store.Get(r, "auth-session")
+	session.Values["authenticated"] = true
+	session.Values["username"] = username
+	if err := session.Save(r, w); err != nil {
+		http.Error(w, "Error saving session", http.StatusInternalServerError)
+		return
+	}
+
+	http.Redirect(w, r, "/", http.StatusSeeOther)
+}
+
+func (ui *Handler) IndexHandler(w http.ResponseWriter, r *http.Request) {
+	data := map[string]interface{}{
+		"Page":  "index",
+		"Title": "Torrents",
+	}
+	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (ui *Handler) DownloadHandler(w http.ResponseWriter, r *http.Request) {
+	data := map[string]interface{}{
+		"Page":  "download",
+		"Title": "Download",
+	}
+	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (ui *Handler) RepairHandler(w http.ResponseWriter, r *http.Request) {
+	data := map[string]interface{}{
+		"Page":  "repair",
+		"Title": "Repair",
+	}
+	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (ui *Handler) ConfigHandler(w http.ResponseWriter, r *http.Request) {
+	data := map[string]interface{}{
+		"Page":  "config",
+		"Title": "Config",
+	}
+	if err := templates.ExecuteTemplate(w, "layout", data); err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (ui *Handler) handleGetArrs(w http.ResponseWriter, r *http.Request) {
+	svc := service.GetService()
+	request.JSONResponse(w, svc.Arr.GetAll(), http.StatusOK)
+}
+
+func (ui *Handler) handleAddContent(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	svc := service.GetService()
+
+	results := make([]*qbit.ImportRequest, 0)
+	errs := make([]string, 0)
+
+	arrName := r.FormValue("arr")
+	notSymlink := r.FormValue("notSymlink") == "true"
+
+	_arr := svc.Arr.Get(arrName)
+	if _arr == nil {
+		_arr = arr.New(arrName, "", "", false)
+	}
+
+	// Handle URLs
+	if urls := r.FormValue("urls"); urls != "" {
+		var urlList []string
+		for _, u := range strings.Split(urls, "\n") {
+			if trimmed := strings.TrimSpace(u); trimmed != "" {
+				urlList = append(urlList, trimmed)
+			}
+		}
+
+		for _, url := range urlList {
+			importReq := qbit.NewImportRequest(url, _arr, !notSymlink)
+			err := importReq.Process(ui.qbit)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("URL %s: %v", url, err))
+				continue
+			}
+			results = append(results, importReq)
+		}
+	}
+
+	// Handle torrent/magnet files
+	if files := r.MultipartForm.File["files"]; len(files) > 0 {
+		for _, fileHeader := range files {
+			file, err := fileHeader.Open()
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("Failed to open file %s: %v", fileHeader.Filename, err))
+				continue
+			}
+
+			magnet, err := utils.GetMagnetFromFile(file, fileHeader.Filename)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("Failed to parse torrent file %s: %v", fileHeader.Filename, err))
+				continue
+			}
+
+			importReq := qbit.NewImportRequest(magnet.Link, _arr, !notSymlink)
+			err = importReq.Process(ui.qbit)
+			if err != nil {
+				errs = append(errs, fmt.Sprintf("File %s: %v", fileHeader.Filename, err))
+				continue
+			}
+			results = append(results, importReq)
+		}
+	}
+
+	request.JSONResponse(w, struct {
+		Results []*qbit.ImportRequest `json:"results"`
+		Errors  []string              `json:"errors,omitempty"`
+	}{
+		Results: results,
+		Errors:  errs,
+	}, http.StatusOK)
+}
+
+func (ui *Handler) handleRepairMedia(w http.ResponseWriter, r *http.Request) {
+	var req RepairRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	svc := service.GetService()
+
+	_arr := svc.Arr.Get(req.ArrName)
+	if _arr == nil {
+		http.Error(w, "No Arrs found to repair", http.StatusNotFound)
+		return
+	}
+
+	if req.Async {
+		go func() {
+			if err := svc.Repair.Repair([]*arr.Arr{_arr}, req.MediaIds); err != nil {
+				ui.logger.Error().Err(err).Msg("Failed to repair media")
+			}
+		}()
+		request.JSONResponse(w, "Repair process started", http.StatusOK)
+		return
+	}
+
+	if err := svc.Repair.Repair([]*arr.Arr{_arr}, req.MediaIds); err != nil {
+		http.Error(w, fmt.Sprintf("Failed to repair: %v", err), http.StatusInternalServerError)
+		return
+
+	}
+
+	request.JSONResponse(w, "Repair completed", http.StatusOK)
+}
+
+func (ui *Handler) handleGetVersion(w http.ResponseWriter, r *http.Request) {
+	v := version.GetInfo()
+	request.JSONResponse(w, v, http.StatusOK)
+}
+
+func (ui *Handler) handleGetTorrents(w http.ResponseWriter, r *http.Request) {
+	request.JSONResponse(w, ui.qbit.Storage.GetAll("", "", nil), http.StatusOK)
+}
+
+func (ui *Handler) handleDeleteTorrent(w http.ResponseWriter, r *http.Request) {
+	hash := chi.URLParam(r, "hash")
+	category := r.URL.Query().Get("category")
+	if hash == "" {
+		http.Error(w, "No hash provided", http.StatusBadRequest)
+		return
+	}
+	ui.qbit.Storage.Delete(hash, category)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (ui *Handler) handleDeleteTorrents(w http.ResponseWriter, r *http.Request) {
+	hashesStr := r.URL.Query().Get("hashes")
+	if hashesStr == "" {
+		http.Error(w, "No hashes provided", http.StatusBadRequest)
+		return
+	}
+	hashes := strings.Split(hashesStr, ",")
+	ui.qbit.Storage.DeleteMultiple(hashes)
+	w.WriteHeader(http.StatusOK)
+}
+
+func (ui *Handler) handleGetConfig(w http.ResponseWriter, r *http.Request) {
+	cfg := config.GetConfig()
+	arrCfgs := make([]config.Arr, 0)
+	svc := service.GetService()
+	for _, a := range svc.Arr.GetAll() {
+		arrCfgs = append(arrCfgs, config.Arr{Host: a.Host, Name: a.Name, Token: a.Token})
+	}
+	cfg.Arrs = arrCfgs
+	request.JSONResponse(w, cfg, http.StatusOK)
+}

pkg/web/web/config.html

@@ -21,6 +21,54 @@
                                 </select>
                             </div>
                             </div>
+                            <!-- Register Magnet Link Button -->
+                             <div class="col-md-6">
+                                <label>
+                                    <!-- Empty label to keep the button aligned -->
+                                </label>
+                                <div class="btn btn-primary w-100" onclick="registerMagnetLinkHandler()" id="registerMagnetLink">
+                                    Open Magnet Links in DecyphArr
+                                </div>
+                            </div>
+                            <div class="col-12 mt-3">
+                                <div class="form-group">
+                                    <label for="allowedExtensions">Allowed File Extensions</label>
+                                    <div class="input-group">
+                                        <textarea type="text"
+                                               class="form-control"
+                                               id="allowedExtensions"
+                                               name="allowed_file_types"
+                                               disabled
+                                               placeholder="mkv, mp4, avi, etc.">
+                                        </textarea>
+                                    </div>
+                                </div>
+                            </div>
+                            <div class="col-md-6 mt-3">
+                                <div class="form-group">
+                                    <label for="minFileSize">Minimum File Size</label>
+                                    <input type="text"
+                                           class="form-control"
+                                           id="minFileSize"
+                                           name="min_file_size"
+                                           disabled
+                                           placeholder="e.g., 10MB, 1GB">
+                                    <small class="form-text text-muted">Minimum file size to download (0 for no limit)</small>
+                                </div>
+                            </div>
+
+                            <div class="col-md-6 mt-3">
+                                <div class="form-group">
+                                    <label for="maxFileSize">Maximum File Size</label>
+                                    <input type="text"
+                                           class="form-control"
+                                           id="maxFileSize"
+                                           name="max_file_size"
+                                           disabled
+                                           placeholder="e.g., 50GB, 100MB">
+                                    <small class="form-text text-muted">Maximum file size to download (0 for no limit)</small>
+                                </div>
+                            </div>
                         </div>
                     </div>
                     <!-- Debrid Configuration -->
@@ -75,7 +123,7 @@
                     </div>
 
                     <!-- Repair Configuration -->
-                    <div class="section">
+                    <div class="section mb-5">
                         <h5 class="border-bottom pb-2">Repair Configuration</h5>
                         <div class="row">
                             <div class="col-md-6 mb-3">
@@ -207,6 +255,15 @@
 
                     const logLevel = document.getElementById('log-level');
                     logLevel.value = config.log_level;
+                    if (config.allowed_file_types && Array.isArray(config.allowed_file_types)) {
+                        document.querySelector('[name="allowed_file_types"]').value = config.allowed_file_types.join(', ');
+                    }
+                    if (config.min_file_size) {
+                        document.querySelector('[name="min_file_size"]').value = config.min_file_size;
+                    }
+                    if (config.max_file_size) {
+                        document.querySelector('[name="max_file_size"]').value = config.max_file_size;
+                    }
 
                 });
 
@@ -259,9 +316,9 @@
 
                     if (!response.ok) throw new Error(await response.text());
 
-                    alert('Configuration saved successfully!');
+                    createToast('Configuration saved successfully!');
                 } catch (error) {
-                    alert(`Error saving configuration: ${error.message}`);
+                    createToast(`Error saving configuration: ${error.message}`, 'error');
                 }
             });
 
@@ -306,5 +363,31 @@
                 arrCount++;
             }
         });
+
+
+        // Register magnet link handler
+        function registerMagnetLinkHandler() {
+            if ('registerProtocolHandler' in navigator) {
+                try {
+                    navigator.registerProtocolHandler(
+                        'magnet',
+                        `${window.location.origin}/download?magnet=%s`,
+                        'DecyphArr'
+                    );
+                    localStorage.setItem('magnetHandler', 'true');
+                    document.getElementById('registerMagnetLink').innerText = '✅ DecyphArr Can Open Magnet Links';
+                    document.getElementById('registerMagnetLink').classList.add('bg-white', 'text-black');
+                    console.log('Registered magnet link handler successfully.');
+                } catch (error) {
+                    console.error('Failed to register magnet link handler:', error);
+                }
+            }
+        }
+
+        var magnetHandler = localStorage.getItem('magnetHandler');
+        if (magnetHandler === 'true') {
+            document.getElementById('registerMagnetLink').innerText = '✅ DecyphArr Can Open Magnet Links';
+            document.getElementById('registerMagnetLink').classList.add('bg-white', 'text-black');
+        }
     </script>
 {{ end }}

pkg/web/web/download.html

@@ -0,0 +1,142 @@
+{{ define "download" }}
+    <div class="container mt-4">
+        <div class="card">
+            <div class="card-header">
+                <h4 class="mb-0"><i class="bi bi-cloud-download me-2"></i>Add New Download</h4>
+            </div>
+            <div class="card-body">
+                <form id="downloadForm" enctype="multipart/form-data">
+                    <div class="mb-2">
+                        <label for="magnetURI" class="form-label">Torrent(s)</label>
+                        <textarea class="form-control" id="magnetURI" name="urls" rows="8" placeholder="Paste your magnet links or torrent URLs here, one per line..."></textarea>
+                    </div>
+
+                    <div class="mb-3">
+                        <input type="file" class="form-control" id="torrentFiles" name="torrents" multiple accept=".torrent,.magnet">
+                    </div>
+
+                    <hr />
+
+                    <div class="mb-3">
+                        <label for="category" class="form-label">Enter Category</label>
+                        <input type="text" class="form-control" id="category" name="arr" placeholder="Enter Category (e.g sonarr, radarr, radarr4k)">
+                    </div>
+
+                    <div class="mb-3">
+                        <div class="form-check">
+                            <input class="form-check-input" type="checkbox" id="isSymlink" name="notSymlink">
+                            <label class="form-check-label" for="isSymlink">
+                                Download real files instead of symlinks
+                            </label>
+                        </div>
+                    </div>
+
+                    <button type="submit" class="btn btn-primary" id="submitDownload">
+                        <i class="bi bi-cloud-upload me-2"></i>Add to Download Queue
+                    </button>
+                </form>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const loadSavedDownloadOptions = () => {
+                const savedCategory = localStorage.getItem('downloadCategory');
+                const savedSymlink = localStorage.getItem('downloadSymlink');
+                document.getElementById('category').value = savedCategory || '';
+                document.getElementById('isSymlink').checked = savedSymlink === 'true'
+            };
+
+            const saveCurrentDownloadOptions = () => {
+                const category = document.getElementById('category').value;
+                const isSymlink = document.getElementById('isSymlink').checked;
+                localStorage.setItem('downloadCategory', category);
+                localStorage.setItem('downloadSymlink', isSymlink.toString());
+            };
+
+            // Load the last used download options from local storage
+            loadSavedDownloadOptions();
+
+            // Handle form submission
+            document.getElementById('downloadForm').addEventListener('submit', async (e) => {
+                e.preventDefault();
+                const submitBtn = document.getElementById('submitDownload');
+                const originalText = submitBtn.innerHTML;
+
+                submitBtn.disabled = true;
+                submitBtn.innerHTML = '<span class="spinner-border spinner-border-sm me-2"></span>Adding...';
+
+                try {
+                    const formData = new FormData();
+                    
+                    // Add URLs if present
+                    const urls = document.getElementById('magnetURI').value
+                        .split('\n')
+                        .map(url => url.trim())
+                        .filter(url => url.length > 0);
+
+                    if (urls.length > 0) {
+                        formData.append('urls', urls.join('\n'));
+                    }
+
+                    // Add torrent files if present
+                    const fileInput = document.getElementById('torrentFiles');
+                    for (let i = 0; i < fileInput.files.length; i++) {
+                        formData.append('files', fileInput.files[i]);
+                    }
+
+                    if (urls.length + fileInput.files.length === 0) {
+                        createToast('Please submit at least one torrent', 'warning');
+                        return;
+                    }
+
+                    if (urls.length + fileInput.files.length > 100) {
+                        createToast('Please submit up to 100 torrents at a time', 'warning');
+                        return;
+                    }
+
+                    formData.append('arr', document.getElementById('category').value);
+                    formData.append('notSymlink', document.getElementById('isSymlink').checked);
+
+                    const response = await fetch('/internal/add', {
+                        method: 'POST',
+                        body: formData
+                    });
+
+                    const result = await response.json();
+                    if (!response.ok) throw new Error(result.error || 'Unknown error');
+                    if (result.errors && result.errors.length > 0) {
+                        if (result.results.length > 0) {
+                            createToast(`Added ${result.results.length} torrents with ${result.errors.length} errors:\n${result.errors.join('\n')}`, 'warning');
+                        } else {
+                            createToast(`Failed to add torrents:\n${result.errors.join('\n')}`, 'error');
+                        }
+                    } else {
+                        createToast(`Successfully added ${result.results.length} torrents!`);
+                    }
+
+                    document.getElementById('magnetURI').value = '';
+                    document.getElementById('torrentFiles').value = '';
+                } catch (error) {
+                    createToast(`Error adding downloads: ${error.message}`, 'error');
+                } finally {
+                    submitBtn.disabled = false;
+                    submitBtn.innerHTML = originalText;
+                }
+            });
+
+            // Save the download options to local storage when they change
+            document.getElementById('category').addEventListener('change', saveCurrentDownloadOptions);
+            document.getElementById('isSymlink').addEventListener('change', saveCurrentDownloadOptions);
+
+            // Read the URL parameters for a magnet link and add it to the download queue if found
+            const urlParams = new URLSearchParams(window.location.search);
+            const magnetURI = urlParams.get('magnet');
+            if (magnetURI) {
+                document.getElementById('magnetURI').value = magnetURI;
+                history.replaceState({}, document.title, window.location.pathname);
+            }
+        });
+    </script>
+{{ end }}

pkg/web/web/index.html

@@ -0,0 +1,246 @@
+{{ define "index" }}
+    <div class="container mt-4">
+        <div class="card">
+            <div class="card-header d-flex justify-content-between align-items-center gap-4">
+                <h4 class="mb-0 text-nowrap"><i class="bi bi-table me-2"></i>Active Torrents</h4>
+                <div class="d-flex align-items-center overflow-auto" style="flex-wrap: nowrap; gap: 0.5rem;">
+                    <button class="btn btn-outline-danger btn-sm" id="batchDeleteBtn" style="display: none; flex-shrink: 0;">
+                        <i class="bi bi-trash me-1"></i>Delete Selected
+                    </button>
+                    <button class="btn btn-outline-secondary btn-sm me-2" id="refreshBtn" style="flex-shrink: 0;">
+                        <i class="bi bi-arrow-clockwise me-1"></i>Refresh
+                    </button>
+                    <select class="form-select form-select-sm d-inline-block w-auto me-2" id="stateFilter" style="flex-shrink: 0;">
+                        <option value="">All States</option>
+                        <option value="downloading">Downloading</option>
+                        <option value="pausedup">Paused</option>
+                        <option value="error">Error</option>
+                    </select>
+                    <select class="form-select form-select-sm d-inline-block w-auto" id="categoryFilter">
+                        <option value="">All Categories</option>
+                    </select>
+                </div>
+            </div>
+            <div class="card-body p-0">
+                <div class="table-responsive">
+                    <table class="table table-hover mb-0">
+                        <thead>
+                        <tr>
+                            <th>
+                                <input type="checkbox" class="form-check-input" id="selectAll">
+                            </th>
+                            <th>Name</th>
+                            <th>Size</th>
+                            <th>Progress</th>
+                            <th>Speed</th>
+                            <th>Category</th>
+                            <th>Debrid</th>
+                            <th>State</th>
+                            <th>Actions</th>
+                        </tr>
+                        </thead>
+                        <tbody id="torrentsList">
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+    </div>
+    <script>
+        let refs = {
+            torrentsList: document.getElementById('torrentsList'),
+            categoryFilter: document.getElementById('categoryFilter'),
+            stateFilter: document.getElementById('stateFilter'),
+            selectAll: document.getElementById('selectAll'),
+            batchDeleteBtn: document.getElementById('batchDeleteBtn'),
+            refreshBtn: document.getElementById('refreshBtn'),
+        };
+        let state = {
+            torrents: [],
+            selectedTorrents: new Set(),
+            categories: new Set(),
+            states: new Set('downloading', 'pausedup', 'error'),
+            selectedCategory: refs.categoryFilter?.value || '',
+            selectedState: refs.stateFilter?.value || '',
+        };
+
+        const torrentRowTemplate = (torrent) => `
+        <tr data-hash="${torrent.hash}">
+            <td>
+                <input type="checkbox" class="form-check-input torrent-select" data-hash="${torrent.hash}" ${state.selectedTorrents.has(torrent.hash) ? 'checked' : ''}>
+            </td>
+            <td class="text-nowrap text-truncate overflow-hidden" style="max-width: 350px;" title="${torrent.name}">${torrent.name}</td>
+            <td class="text-nowrap">${formatBytes(torrent.size)}</td>
+            <td style="min-width: 150px;">
+                <div class="progress" style="height: 8px;">
+                    <div class="progress-bar" role="progressbar"
+                         style="width: ${(torrent.progress * 100).toFixed(1)}%"
+                         aria-valuenow="${(torrent.progress * 100).toFixed(1)}"
+                         aria-valuemin="0"
+                         aria-valuemax="100"></div>
+                </div>
+                <small class="text-muted">${(torrent.progress * 100).toFixed(1)}%</small>
+            </td>
+            <td>${formatSpeed(torrent.dlspeed)}</td>
+            <td><span class="badge bg-secondary">${torrent.category || 'None'}</span></td>
+            <td>${torrent.debrid || 'None'}</td>
+            <td><span class="badge ${getStateColor(torrent.state)}">${torrent.state}</span></td>
+            <td>
+                <button class="btn btn-sm btn-outline-danger" onclick="deleteTorrent('${torrent.hash}', '${torrent.category}')">
+                    <i class="bi bi-trash"></i>
+                </button>
+            </td>
+        </tr>
+        `;
+
+        function formatBytes(bytes) {
+            if (!bytes) return '0 B';
+            const k = 1024;
+            const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+            const i = Math.floor(Math.log(bytes) / Math.log(k));
+            return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+        }
+
+        function formatSpeed(speed) {
+            return `${formatBytes(speed)}/s`;
+        }
+
+        function getStateColor(state) {
+            const stateColors = {
+                'downloading': 'bg-primary',
+                'pausedup': 'bg-success',
+                'error': 'bg-danger',
+            };
+            return stateColors[state?.toLowerCase()] || 'bg-secondary';
+        }
+
+        function updateUI() {
+            // Filter torrents by selected category and state
+            let filteredTorrents = state.torrents;
+            if (state.selectedCategory) {
+                filteredTorrents = filteredTorrents.filter(t => t.category === state.selectedCategory);
+            }
+            if (state.selectedState) {
+                filteredTorrents = filteredTorrents.filter(t => t.state === state.selectedState);
+            }
+
+            // Update the torrents list table
+            refs.torrentsList.innerHTML = filteredTorrents.map(torrent => torrentRowTemplate(torrent)).join('');
+
+            // Update the category filter dropdown
+            const currentCategories = Array.from(state.categories).sort();
+            const categoryOptions = ['<option value="">All Categories</option>']
+                .concat(currentCategories.map(cat => 
+                    `<option value="${cat}" ${cat === state.selectedCategory ? 'selected' : ''}>${cat}</option>`
+                ));
+            refs.categoryFilter.innerHTML = categoryOptions.join('');
+
+            // Clean up selected torrents that no longer exist
+            state.selectedTorrents = new Set(
+                Array.from(state.selectedTorrents)
+                    .filter(hash => filteredTorrents.some(t => t.hash === hash))
+            );
+
+            // Update batch delete button visibility
+            refs.batchDeleteBtn.style.display = state.selectedTorrents.size > 0 ? '' : 'none';
+
+            // Update the select all checkbox state
+            refs.selectAll.checked = filteredTorrents.length > 0 && filteredTorrents.every(torrent => state.selectedTorrents.has(torrent.hash));
+        }
+
+        async function loadTorrents() {
+            try {
+                const response = await fetch('/internal/torrents');
+                const torrents = await response.json();
+                
+                state.torrents = torrents;
+                state.categories = new Set(torrents.map(t => t.category).filter(Boolean));
+                
+                updateUI();
+            } catch (error) {
+                console.error('Error loading torrents:', error);
+            }
+        }
+
+        async function deleteTorrent(hash, category) {
+            if (!confirm('Are you sure you want to delete this torrent?')) return;
+
+            try {
+                await fetch(`/internal/torrents/${category}/${hash}`, {
+                    method: 'DELETE'
+                });
+                await loadTorrents();
+                createToast('Torrent deleted successfully');
+            } catch (error) {
+                console.error('Error deleting torrent:', error);
+                createToast('Failed to delete torrent', 'error');
+            }
+        }
+
+        async function deleteSelectedTorrents() {
+            if (!confirm(`Are you sure you want to delete ${state.selectedTorrents.size} selected torrents?`)) return;
+
+            try {
+                // COmma separated list of hashes
+                const hashes = Array.from(state.selectedTorrents).join(',');
+                await fetch(`/internal/torrents/?hashes=${encodeURIComponent(hashes)}`, {
+                    method: 'DELETE'
+                });
+                await loadTorrents();
+                createToast('Selected torrents deleted successfully');
+            } catch (error) {
+                console.error('Error deleting torrents:', error);
+                createToast('Failed to delete some torrents' , 'error');
+            }
+        }
+
+        document.addEventListener('DOMContentLoaded', () => {
+            loadTorrents();
+            const refreshInterval = setInterval(loadTorrents, 5000);
+
+            refs.refreshBtn.addEventListener('click', loadTorrents);
+            refs.batchDeleteBtn.addEventListener('click', deleteSelectedTorrents);
+
+            refs.selectAll.addEventListener('change', (e) => {
+                const filteredTorrents = state.torrents.filter(t => {
+                    if (state.selectedCategory && t.category !== state.selectedCategory) return false;
+                    if (state.selectedState && t.state?.toLowerCase() !== state.selectedState.toLowerCase()) return false;
+                    return true;
+                });
+                    
+                if (e.target.checked) {
+                    filteredTorrents.forEach(torrent => state.selectedTorrents.add(torrent.hash));
+                } else {
+                    filteredTorrents.forEach(torrent => state.selectedTorrents.delete(torrent.hash));
+                }
+                updateUI();
+            });
+
+            refs.torrentsList.addEventListener('change', (e) => {
+                if (e.target.classList.contains('torrent-select')) {
+                    const hash = e.target.dataset.hash;
+                    if (e.target.checked) {
+                        state.selectedTorrents.add(hash);
+                    } else {
+                        state.selectedTorrents.delete(hash);
+                    }
+                    updateUI();
+                }
+            });
+
+            refs.categoryFilter.addEventListener('change', (e) => {
+                state.selectedCategory = e.target.value;
+                updateUI();
+            });
+
+            refs.stateFilter.addEventListener('change', (e) => {
+                state.selectedState = e.target.value;
+                updateUI();
+            });
+
+            window.addEventListener('beforeunload', () => {
+                clearInterval(refreshInterval);
+            });
+        });
+    </script>
+{{ end }}

pkg/web/web/layout.html

@@ -57,6 +57,9 @@
         </style>
     </head>
     <body>
+    <div class="toast-container position-fixed bottom-0 end-0 p-3">
+        <!-- Toast messages will be created dynamically here -->
+    </div>
     <nav class="navbar navbar-expand-lg navbar-light mb-4">
         <div class="container">
             <a class="navbar-brand" href="/">
@@ -109,12 +112,63 @@
     {{ template "repair" . }}
     {{ else if eq .Page "config" }}
     {{ template "config" . }}
+    {{ else if eq .Page "login" }}
+    {{ template "login" . }}
+    {{ else if eq .Page "setup" }}
+    {{ template "setup" . }}
+    {{ else }}
     {{ end }}
 
     <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"></script>
     <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/js/select2.min.js"></script>
     <script>
+        /**
+         * Create a toast message
+         * @param {string} message - The message to display
+         * @param {string} [type='success'] - The type of toast (success, warning, error)
+         */
+        const createToast = (message, type = 'success') => {
+            type = ['success', 'warning', 'error'].includes(type) ? type : 'success';
+
+            const toastTimeouts = {
+                success: 5000,
+                warning: 10000,
+                error: 15000
+            }
+
+            const toastContainer = document.querySelector('.toast-container');
+            const toastId = `toast-${Date.now()}`;
+            
+            const toastHtml = `
+            <div id="${toastId}" class="toast" role="alert" aria-live="assertive" aria-atomic="true">
+                <div class="toast-header ${type === 'error' ? 'bg-danger text-white' : type === 'warning' ? 'bg-warning text-dark' : 'bg-success text-white'}">
+                <strong class="me-auto">
+                    ${type === 'error' ? 'Error' : type === 'warning' ? 'Warning' : 'Success'}
+                </strong>
+                <button type="button" class="btn-close ${type === 'warning' ? '' : 'btn-close-white'}" data-bs-dismiss="toast" aria-label="Close"></button>
+                </div>
+                <div class="toast-body">
+                ${message.replace(/\n/g, '<br>')}
+                </div>
+            </div>
+            `;
+            
+            toastContainer.insertAdjacentHTML('beforeend', toastHtml);
+            
+            const toastElement = document.getElementById(toastId);
+            const toast = new bootstrap.Toast(toastElement, {
+                autohide: true,
+                delay: toastTimeouts[type]
+            });
+            
+            toast.show();
+            
+            toastElement.addEventListener('hidden.bs.toast', () => {
+            toastElement.remove();
+            });
+        };
+
         document.addEventListener('DOMContentLoaded', function() {
             fetch('/internal/version')
                 .then(response => response.json())

pkg/web/web/login.html

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

pkg/web/web/repair.html

@@ -62,7 +62,7 @@
             let mediaIds = document.getElementById('mediaIds').value.split(',').map(id => id.trim());
             let arr = document.getElementById('arrSelect').value;
             if (!arr) {
-                alert('Please select an Arr instance');
+                createToast('Please select an Arr instance', 'warning');
                 submitBtn.disabled = false;
                 submitBtn.innerHTML = originalText;
                 return;
@@ -81,9 +81,9 @@
                 });
 
                 if (!response.ok) throw new Error(await response.text());
-                alert('Repair process initiated successfully!');
+                createToast('Repair process initiated successfully!');
             } catch (error) {
-                alert(`Error starting repair: ${error.message}`);
+                createToast(`Error starting repair: ${error.message}`, 'error');
             } finally {
                 submitBtn.disabled = false;
                 submitBtn.innerHTML = originalText;

pkg/web/web/setup.html

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

pkg/webdav/file.go

@@ -0,0 +1,160 @@
+package webdav
+
+import (
+	"fmt"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/cache"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"io"
+	"net/http"
+	"os"
+	"time"
+)
+
+type File struct {
+	cache         *cache.Cache
+	cachedTorrent *cache.CachedTorrent
+	file          *torrent.File
+	offset        int64
+	isDir         bool
+	children      []os.FileInfo
+	reader        io.ReadCloser
+}
+
+// File interface implementations for File
+
+func (f *File) Close() error {
+	return nil
+}
+
+func (f *File) GetDownloadLink() string {
+	file := f.file
+	link, err := f.cache.GetFileDownloadLink(f.cachedTorrent, file)
+	if err != nil {
+		return ""
+	}
+	return link
+}
+
+func (f *File) Read(p []byte) (n int, err error) {
+	// Directories cannot be read as a byte stream.
+	if f.isDir {
+		return 0, os.ErrInvalid
+	}
+
+	// If we haven't started streaming the file yet, open the HTTP connection.
+	if f.reader == nil {
+		// Create an HTTP GET request to the file's URL.
+		req, err := http.NewRequest("GET", f.GetDownloadLink(), nil)
+		if err != nil {
+			return 0, fmt.Errorf("failed to create HTTP request: %w", err)
+		}
+
+		// If we've already read some data (f.offset > 0), request only the remaining bytes.
+		if f.offset > 0 {
+			req.Header.Set("Range", fmt.Sprintf("bytes=%d-", f.offset))
+		}
+
+		// Execute the HTTP request.
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			return 0, fmt.Errorf("HTTP request error: %w", err)
+		}
+
+		// Accept a 200 (OK) or 206 (Partial Content) status.
+		if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusPartialContent {
+			resp.Body.Close()
+			return 0, fmt.Errorf("unexpected HTTP status: %d", resp.StatusCode)
+		}
+
+		// Store the response body as our reader.
+		f.reader = resp.Body
+	}
+
+	// Read data from the HTTP stream.
+	n, err = f.reader.Read(p)
+	f.offset += int64(n)
+
+	// When we reach the end of the stream, close the reader.
+	if err == io.EOF {
+		f.reader.Close()
+		f.reader = nil
+	}
+
+	return n, err
+}
+
+func (f *File) Seek(offset int64, whence int) (int64, error) {
+	if f.isDir {
+		return 0, os.ErrInvalid
+	}
+
+	switch whence {
+	case io.SeekStart:
+		f.offset = offset
+	case io.SeekCurrent:
+		f.offset += offset
+	case io.SeekEnd:
+		f.offset = f.file.Size - offset
+	default:
+		return 0, os.ErrInvalid
+	}
+
+	if f.offset < 0 {
+		f.offset = 0
+	}
+	if f.offset > f.file.Size {
+		f.offset = f.file.Size
+	}
+
+	return f.offset, nil
+}
+
+func (f *File) Readdir(count int) ([]os.FileInfo, error) {
+	if !f.isDir {
+		return nil, os.ErrInvalid
+	}
+
+	if count <= 0 {
+		return f.children, nil
+	}
+
+	if len(f.children) == 0 {
+		return nil, io.EOF
+	}
+
+	if count > len(f.children) {
+		count = len(f.children)
+	}
+
+	files := f.children[:count]
+	f.children = f.children[count:]
+	return files, nil
+}
+
+func (f *File) Stat() (os.FileInfo, error) {
+	if f.isDir {
+		name := "/"
+		if f.cachedTorrent != nil {
+			name = f.cachedTorrent.Name
+		}
+		return &FileInfo{
+			name:    name,
+			size:    0,
+			mode:    0755 | os.ModeDir,
+			modTime: time.Now(),
+			isDir:   true,
+		}, nil
+	}
+
+	return &FileInfo{
+		name:    f.file.Name,
+		size:    f.file.Size,
+		mode:    0644,
+		modTime: time.Now(),
+		isDir:   false,
+	}, nil
+}
+
+func (f *File) Write(p []byte) (n int, err error) {
+	return 0, os.ErrPermission
+}

pkg/webdav/file_info.go

@@ -0,0 +1,22 @@
+package webdav
+
+import (
+	"os"
+	"time"
+)
+
+// FileInfo implements os.FileInfo for our WebDAV files
+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 }

pkg/webdav/handler.go

@@ -0,0 +1,263 @@
+package webdav
+
+import (
+	"context"
+	"fmt"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/cache"
+	"github.com/sirrobot01/debrid-blackhole/pkg/debrid/torrent"
+	"golang.org/x/net/webdav"
+	"html/template"
+	"net/http"
+	"os"
+	"path"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+type Handler struct {
+	Name         string
+	logger       zerolog.Logger
+	cache        *cache.Cache
+	rootListing  atomic.Value
+	lastRefresh  time.Time
+	refreshMutex sync.Mutex
+	RootPath     string
+}
+
+func NewHandler(name string, cache *cache.Cache, logger zerolog.Logger) *Handler {
+	h := &Handler{
+		Name:     name,
+		cache:    cache,
+		logger:   logger,
+		RootPath: fmt.Sprintf("/%s", name),
+	}
+
+	h.refreshRootListing()
+
+	// Start background refresh
+	go h.backgroundRefresh()
+
+	return h
+}
+
+func (h *Handler) backgroundRefresh() {
+	ticker := time.NewTicker(5 * time.Minute)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		h.refreshRootListing()
+	}
+}
+
+func (h *Handler) refreshRootListing() {
+	h.refreshMutex.Lock()
+	defer h.refreshMutex.Unlock()
+
+	if time.Since(h.lastRefresh) < time.Minute {
+		return
+	}
+
+	var files []os.FileInfo
+	h.cache.GetTorrents().Range(func(key, value interface{}) bool {
+		cachedTorrent := value.(*cache.CachedTorrent)
+		if cachedTorrent != nil && cachedTorrent.Torrent != nil {
+			files = append(files, &FileInfo{
+				name:    cachedTorrent.Torrent.Name,
+				size:    0,
+				mode:    0755 | os.ModeDir,
+				modTime: time.Now(),
+				isDir:   true,
+			})
+		}
+		return true
+	})
+
+	h.rootListing.Store(files)
+	h.lastRefresh = time.Now()
+}
+
+func (h *Handler) getParentRootPath() string {
+	return fmt.Sprintf("/webdav/%s", h.Name)
+}
+
+func (h *Handler) getRootFileInfos() []os.FileInfo {
+	if listing := h.rootListing.Load(); listing != nil {
+		return listing.([]os.FileInfo)
+	}
+	return []os.FileInfo{}
+}
+
+// Mkdir implements webdav.FileSystem
+func (h *Handler) Mkdir(ctx context.Context, name string, perm os.FileMode) error {
+	return os.ErrPermission // Read-only filesystem
+}
+
+// RemoveAll implements webdav.FileSystem
+func (h *Handler) RemoveAll(ctx context.Context, name string) error {
+	return os.ErrPermission // Read-only filesystem
+}
+
+// Rename implements webdav.FileSystem
+func (h *Handler) Rename(ctx context.Context, oldName, newName string) error {
+	return os.ErrPermission // Read-only filesystem
+}
+
+func (h *Handler) OpenFile(ctx context.Context, name string, flag int, perm os.FileMode) (webdav.File, error) {
+	name = path.Clean("/" + name)
+
+	// Fast path for root directory
+	if name == h.getParentRootPath() {
+		return &File{
+			cache:    h.cache,
+			isDir:    true,
+			children: h.getRootFileInfos(),
+		}, nil
+	}
+
+	// Remove root directory from path
+	name = strings.TrimPrefix(name, h.getParentRootPath())
+	name = strings.TrimPrefix(name, "/")
+	parts := strings.SplitN(name, "/", 2)
+
+	// Get torrent from cache using sync.Map
+	cachedTorrent := h.cache.GetTorrentByName(parts[0])
+	if cachedTorrent == nil {
+		h.logger.Debug().Msgf("Torrent not found: %s", parts[0])
+		return nil, os.ErrNotExist
+	}
+
+	if len(parts) == 1 {
+		return &File{
+			cache:         h.cache,
+			cachedTorrent: cachedTorrent,
+			isDir:         true,
+			children:      h.getTorrentFileInfos(cachedTorrent.Torrent),
+		}, nil
+	}
+
+	// Use a map for faster file lookup
+	fileMap := make(map[string]*torrent.File, len(cachedTorrent.Torrent.Files))
+	for i := range cachedTorrent.Torrent.Files {
+		fileMap[cachedTorrent.Torrent.Files[i].Name] = &cachedTorrent.Torrent.Files[i]
+	}
+
+	if file, ok := fileMap[parts[1]]; ok {
+		return &File{
+			cache:         h.cache,
+			cachedTorrent: cachedTorrent,
+			file:          file,
+			isDir:         false,
+		}, nil
+	}
+
+	h.logger.Debug().Msgf("File not found: %s", name)
+	return nil, os.ErrNotExist
+}
+
+// Stat implements webdav.FileSystem
+func (h *Handler) Stat(ctx context.Context, name string) (os.FileInfo, error) {
+	f, err := h.OpenFile(ctx, name, os.O_RDONLY, 0)
+	if err != nil {
+		return nil, err
+	}
+	return f.Stat()
+}
+
+func (h *Handler) getTorrentFileInfos(torrent *torrent.Torrent) []os.FileInfo {
+	files := make([]os.FileInfo, 0, len(torrent.Files))
+	for _, file := range torrent.Files {
+		files = append(files, &FileInfo{
+			name:    file.Name,
+			size:    file.Size,
+			mode:    0644,
+			modTime: time.Now(),
+			isDir:   false,
+		})
+	}
+	return files
+}
+
+func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Handle OPTIONS
+	if r.Method == "OPTIONS" {
+		w.WriteHeader(http.StatusOK)
+		return
+	}
+
+	// Create WebDAV handler
+	handler := &webdav.Handler{
+		FileSystem: h,
+		LockSystem: webdav.NewMemLS(),
+		Logger: func(r *http.Request, err error) {
+			if err != nil {
+				h.logger.Error().
+					Err(err).
+					Str("method", r.Method).
+					Str("path", r.URL.Path).
+					Msg("WebDAV error")
+			}
+		},
+	}
+
+	// Special handling for GET requests on directories
+	if r.Method == "GET" {
+		if f, err := h.OpenFile(r.Context(), r.URL.Path, os.O_RDONLY, 0); err == nil {
+			if fi, err := f.Stat(); err == nil && fi.IsDir() {
+				h.serveDirectory(w, r, f)
+				return
+			}
+			f.Close()
+		}
+	}
+	handler.ServeHTTP(w, r)
+}
+
+func (h *Handler) serveDirectory(w http.ResponseWriter, r *http.Request, file webdav.File) {
+	var children []os.FileInfo
+	if f, ok := file.(*File); ok {
+		children = f.children
+	} else {
+		var err error
+		children, err = file.Readdir(-1)
+		if err != nil {
+			http.Error(w, "Failed to list directory", http.StatusInternalServerError)
+			return
+		}
+	}
+
+	// Clean and prepare the path
+	cleanPath := path.Clean(r.URL.Path)
+	parentPath := path.Dir(cleanPath)
+	showParent := cleanPath != "/" && parentPath != "." && parentPath != cleanPath
+
+	// Prepare template data
+	data := struct {
+		Path       string
+		ParentPath string
+		ShowParent bool
+		Children   []os.FileInfo
+	}{
+		Path:       cleanPath,
+		ParentPath: parentPath,
+		ShowParent: showParent,
+		Children:   children,
+	}
+
+	// Parse and execute template
+	tmpl, err := template.New("directory").Parse(directoryTemplate)
+	if err != nil {
+		h.logger.Error().Err(err).Msg("Failed to parse directory template")
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	if err := tmpl.Execute(w, data); err != nil {
+		h.logger.Error().Err(err).Msg("Failed to execute directory template")
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		return
+	}
+}

pkg/webdav/templates.go

@@ -0,0 +1,112 @@
+package webdav
+
+const rootTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>WebDAV Shares</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #2c3e50;
+        }
+        ul {
+            list-style: none;
+            padding: 0;
+        }
+        li {
+            margin: 10px 0;
+        }
+        a {
+            color: #3498db;
+            text-decoration: none;
+            padding: 10px;
+            display: block;
+            border: 1px solid #eee;
+            border-radius: 4px;
+        }
+        a:hover {
+            background-color: #f7f9fa;
+        }
+    </style>
+</head>
+<body>
+    <h1>Available WebDAV Shares</h1>
+    <ul>
+        {{range .Handlers}}
+            <li><a href="{{$.Prefix}}{{.RootPath}}">{{$.Prefix}}{{.RootPath}}</a></li>
+        {{end}}
+    </ul>
+</body>
+</html>
+`
+
+const directoryTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Index of {{.Path}}</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            margin: 0 auto;
+            padding: 20px;
+        }
+        h1 {
+            color: #2c3e50;
+        }
+        ul {
+            list-style: none;
+            padding: 0;
+        }
+        li {
+            margin: 10px 0;
+        }
+        a {
+            color: #3498db;
+            text-decoration: none;
+            padding: 10px;
+            display: block;
+            border: 1px solid #eee;
+            border-radius: 4px;
+        }
+        a:hover {
+            background-color: #f7f9fa;
+        }
+        .file-info {
+            color: #666;
+            font-size: 0.9em;
+            float: right;
+        }
+        .parent-dir {
+            background-color: #f8f9fa;
+        }
+    </style>
+</head>
+<body>
+    <h1>Index of {{.Path}}</h1>
+    <ul>
+        {{if .ShowParent}}
+            <li><a href="{{.ParentPath}}" class="parent-dir">Parent Directory</a></li>
+        {{end}}
+        {{range .Children}}
+            <li>
+                <a href="{{$.Path}}/{{.Name}}">
+                    {{.Name}}{{if .IsDir}}/{{end}}
+                    <span class="file-info">
+                        {{if not .IsDir}}
+                            {{.Size}} bytes
+                        {{end}}
+                        {{.ModTime.Format "2006-01-02 15:04:05"}}
+                    </span>
+                </a>
+            </li>
+        {{end}}
+    </ul>
+</body>
+</html>
+`

pkg/webdav/webdav.go

@@ -0,0 +1,126 @@
+package webdav
+
+import (
+	"context"
+	"fmt"
+	"github.com/go-chi/chi/v5"
+	"html/template"
+	"net/http"
+	"sync"
+)
+
+type WebDav struct {
+	Handlers []*Handler
+}
+
+func New() *WebDav {
+	//svc := service.GetService()
+	//cfg := config.GetConfig()
+	w := &WebDav{
+		Handlers: make([]*Handler, 0),
+	}
+	//for name, c := range svc.DebridCache.GetCaches() {
+	//	h := NewHandler(name, c, logger.NewLogger(fmt.Sprintf("%s-webdav", name), cfg.LogLevel, os.Stdout))
+	//	w.Handlers = append(w.Handlers, h)
+	//}
+	return w
+}
+
+func (wd *WebDav) Routes() http.Handler {
+	chi.RegisterMethod("PROPFIND")
+	chi.RegisterMethod("PROPPATCH")
+	chi.RegisterMethod("MKCOL") // Note: it was "MKOL" in your example, should be "MKCOL"
+	chi.RegisterMethod("COPY")
+	chi.RegisterMethod("MOVE")
+	chi.RegisterMethod("LOCK")
+	chi.RegisterMethod("UNLOCK")
+	wr := chi.NewRouter()
+	wr.Use(wd.commonMiddleware)
+
+	wd.setupRootHandler(wr)
+	wd.mountHandlers(wr)
+
+	return wr
+}
+
+func (wd *WebDav) Start(ctx context.Context) error {
+	wg := sync.WaitGroup{}
+	errChan := make(chan error, len(wd.Handlers))
+
+	for _, h := range wd.Handlers {
+		wg.Add(1)
+		go func(h *Handler) {
+			defer wg.Done()
+			if err := h.cache.Start(); err != nil {
+				select {
+				case errChan <- err:
+				default:
+				}
+			}
+		}(h)
+	}
+
+	// Use a separate goroutine to close channel after WaitGroup
+	go func() {
+		wg.Wait()
+		close(errChan)
+	}()
+
+	// Collect all errors
+	var errors []error
+	for err := range errChan {
+		if err != nil {
+			errors = append(errors, err)
+		}
+	}
+
+	if len(errors) > 0 {
+		return fmt.Errorf("multiple handlers failed: %v", errors)
+	}
+	return nil
+}
+
+func (wd *WebDav) mountHandlers(r chi.Router) {
+	for _, h := range wd.Handlers {
+		r.Mount(h.RootPath, h)
+	}
+}
+
+func (wd *WebDav) setupRootHandler(r chi.Router) {
+	r.Get("/", wd.handleRoot())
+}
+
+func (wd *WebDav) commonMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("DAV", "1, 2")
+		w.Header().Set("Allow", "OPTIONS, PROPFIND, GET, HEAD, POST, PUT, DELETE, MKCOL, PROPPATCH, COPY, MOVE, LOCK, UNLOCK")
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Access-Control-Allow-Methods", "OPTIONS, PROPFIND, GET, HEAD, POST, PUT, DELETE, MKCOL, PROPPATCH, COPY, MOVE, LOCK, UNLOCK")
+		w.Header().Set("Access-Control-Allow-Headers", "Depth, Content-Type, Authorization")
+
+		next.ServeHTTP(w, r)
+	})
+}
+
+func (wd *WebDav) handleRoot() http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+
+		tmpl, err := template.New("root").Parse(rootTemplate)
+		if err != nil {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		data := struct {
+			Handlers []*Handler
+			Prefix   string
+		}{
+			Handlers: wd.Handlers,
+			Prefix:   "/webdav",
+		}
+		if err := tmpl.Execute(w, data); err != nil {
+			return
+		}
+	}
+}

pkg/worker/worker.go

@@ -0,0 +1,131 @@
+package worker
+
+import (
+	"context"
+	"github.com/rs/zerolog"
+	"github.com/sirrobot01/debrid-blackhole/internal/config"
+	"github.com/sirrobot01/debrid-blackhole/internal/logger"
+	"github.com/sirrobot01/debrid-blackhole/pkg/arr"
+	"github.com/sirrobot01/debrid-blackhole/pkg/service"
+	"os"
+	"sync"
+	"time"
+)
+
+var (
+	_logInstance zerolog.Logger
+	once         sync.Once
+)
+
+func getLogger() zerolog.Logger {
+
+	once.Do(func() {
+		cfg := config.GetConfig()
+		_logInstance = logger.NewLogger("worker", cfg.LogLevel, os.Stdout)
+	})
+	return _logInstance
+}
+
+func Start(ctx context.Context) error {
+	cfg := config.GetConfig()
+	// Start Arr Refresh Worker
+
+	var wg sync.WaitGroup
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		arrRefreshWorker(ctx, cfg)
+	}()
+
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		cleanUpQueuesWorker(ctx, cfg)
+	}()
+	wg.Wait()
+	return nil
+}
+
+func arrRefreshWorker(ctx context.Context, cfg *config.Config) {
+	// Start Arr Refresh Worker
+	_logger := getLogger()
+	_logger.Debug().Msg("Refresh Worker started")
+	refreshCtx := context.WithValue(ctx, "worker", "refresh")
+	refreshTicker := time.NewTicker(time.Duration(cfg.QBitTorrent.RefreshInterval) * time.Second)
+	var refreshMutex sync.Mutex
+
+	for {
+		select {
+		case <-refreshCtx.Done():
+			_logger.Debug().Msg("Refresh Worker stopped")
+			return
+		case <-refreshTicker.C:
+			if refreshMutex.TryLock() {
+				go func() {
+					defer refreshMutex.Unlock()
+					refreshArrs()
+				}()
+			} else {
+				_logger.Debug().Msg("Previous refresh still running, skipping this cycle")
+			}
+		}
+	}
+}
+
+func cleanUpQueuesWorker(ctx context.Context, cfg *config.Config) {
+	// Start Clean up Queues Worker
+	_logger := getLogger()
+	_arrs := service.GetService().Arr
+	filtered := make([]*arr.Arr, 0)
+	for _, a := range _arrs.GetAll() {
+		if a.Cleanup {
+			filtered = append(filtered, a)
+		}
+	}
+	if len(filtered) == 0 {
+		_logger.Debug().Msg("No ARR instances configured for cleanup")
+		return
+	}
+	_logger.Debug().Msg("Clean up Queues Worker started")
+	cleanupCtx := context.WithValue(ctx, "worker", "cleanup")
+	cleanupTicker := time.NewTicker(time.Duration(10) * time.Second)
+
+	var cleanupMutex sync.Mutex
+
+	for {
+		select {
+		case <-cleanupCtx.Done():
+			_logger.Debug().Msg("Clean up Queues Worker stopped")
+			return
+		case <-cleanupTicker.C:
+			if cleanupMutex.TryLock() {
+				go func() {
+					defer cleanupMutex.Unlock()
+					cleanUpQueues(filtered)
+				}()
+			}
+		}
+	}
+}
+
+func refreshArrs() {
+	arrs := service.GetService().Arr
+	for _, arr := range arrs.GetAll() {
+		err := arr.Refresh()
+		if err != nil {
+			return
+		}
+	}
+}
+
+func cleanUpQueues(arrs []*arr.Arr) {
+	// Clean up queues
+	_logger := getLogger()
+	for _, a := range arrs {
+		_logger.Debug().Msgf("Cleaning up queue for %s", a.Name)
+		if err := a.CleanupQueue(); err != nil {
+			_logger.Debug().Err(err).Msg("Error cleaning up queue")
+		}
+	}
+}