Fix magnet conversion

Co-authored-by: Tangui <tanguidaoudal@yahoo.fr>

.air.toml

@@ -0,0 +1,52 @@
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+  args_bin = []
+  bin = "./tmp/main"
+  cmd = "go build -o ./tmp/main ."
+  delay = 1000
+  exclude_dir = ["assets", "tmp", "vendor", "testdata", "data"]
+  exclude_file = []
+  exclude_regex = ["_test.go"]
+  exclude_unchanged = false
+  follow_symlink = false
+  full_bin = ""
+  include_dir = []
+  include_ext = ["go", "tpl", "tmpl", "html", ".json"]
+  include_file = []
+  kill_delay = "0s"
+  log = "build-errors.log"
+  poll = false
+  poll_interval = 0
+  post_cmd = []
+  pre_cmd = []
+  rerun = false
+  rerun_delay = 500
+  send_interrupt = false
+  stop_on_error = false
+
+[color]
+  app = ""
+  build = "yellow"
+  main = "magenta"
+  runner = "green"
+  watcher = "cyan"
+
+[log]
+  main_only = false
+  silent = false
+  time = false
+
+[misc]
+  clean_on_exit = false
+
+[proxy]
+  app_port = 0
+  enabled = false
+  proxy_port = 0
+
+[screen]
+  clear_on_rebuild = false
+  keep_scroll = true

.dockerignore

@@ -5,4 +5,5 @@ docker-compose.yml
 .DS_Store
 **/.idea/
 *.magnet
-**.torrent
+**.torrent
+

.github/workflows/docker.yml

@@ -0,0 +1,54 @@
+name: Docker Build and Push
+
+on:
+  push:
+    branches:
+      - main
+      - beta
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get version
+        id: get_version
+        run: |
+          LATEST_TAG=$(git tag | sort -V | tail -n1)
+          echo "latest_tag=${LATEST_TAG}" >> $GITHUB_ENV
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push for beta branch
+        if: github.ref == 'refs/heads/beta'
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          push: true
+          tags: cy01/blackhole:beta
+
+      - name: Build and push for main branch
+        if: github.ref == 'refs/heads/main'
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64,linux/arm/v7
+          push: true
+          tags: |
+            cy01/blackhole:latest
+            cy01/blackhole:${{ env.latest_tag }}

.github/workflows/release.yml

@@ -0,0 +1,32 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - '*'
+
+permissions:
+  contents: write
+
+jobs:
+  goreleaser:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.22'
+          
+      - name: Run GoReleaser
+        uses: goreleaser/goreleaser-action@v5
+        with:
+          distribution: goreleaser
+          version: latest
+          args: release --clean
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -9,3 +9,4 @@ docker-compose.yml
 *.log
 *.log.*
 dist/
+tmp/**

.goreleaser.yaml

@@ -1,4 +1,4 @@
-version: 2
+version: 1
 
 before:
   hooks:

CHANGELOG.md

@@ -0,0 +1,99 @@
+#### 0.1.0
+- Initial Release
+- Added Real Debrid Support
+- Added Arrs Support
+- Added Proxy Support
+- Added Basic Authentication for Proxy
+- Added Rate Limiting for Debrid Providers
+
+#### 0.1.1
+- Added support for "No Blackhole" for Arrs
+- Added support for "Cached Only" for Proxy
+- Bug Fixes
+
+#### 0.1.2
+- Bug fixes
+- Code cleanup
+- Get available hashes at once
+
+#### 0.1.3
+
+- Searching for infohashes in the xml description/summary/comments
+- Added local cache support
+- Added max cache size
+- Rewrite blackhole.go
+- Bug fixes
+  - Fixed indexer getting disabled
+  - Fixed blackhole not working
+
+#### 0.1.4
+
+- Rewrote Report log
+- Fix YTS, 1337x not grabbing infohash
+- Fix Torrent symlink bug
+
+
+#### 0.2.0-beta
+
+- Switch to QbitTorrent API instead of Blackhole
+- Rewrote the whole codebase
+
+
+#### 0.2.0
+- Implement 0.2.0-beta changes
+- Removed Blackhole
+- Added QbitTorrent API
+- Cleaned up the code
+
+#### 0.2.1
+
+- Fix Uncached torrents not being downloaded/downloaded
+- Minor bug fixed
+- Fix Race condition in the cache and file system
+
+#### 0.2.2
+- Fix name mismatch in the cache
+- Fix directory mapping with mounts
+- Add Support for refreshing the *arrs
+
+#### 0.2.3
+
+- Delete uncached items from RD
+- Fail if the torrent is not cached(optional)
+- Fix cache not being updated
+
+#### 0.2.4
+
+- Add file download support(Sequential Download)
+- Fix http handler error
+- Fix *arrs map failing concurrently
+- Fix cache not being updated
+
+#### 0.2.5
+- Fix ContentPath not being set prior
+- Rewrote Readme
+- Cleaned up the code
+
+#### 0.2.6
+- Delete torrent for empty matched files
+- Update Readme
+
+#### 0.2.7
+
+- Add support for multiple debrid providers
+- Add Torbox support
+- Add support for configurable debrid cache checks
+- Add support for configurable debrid download uncached torrents
+
+#### 0.3.0
+
+- Add UI for adding torrents
+- Refraction of the code
+- -Fix Torbox bug
+- Update CI/CD
+- Update Readme
+
+#### 0.3.1
+
+- Add DebridLink Support
+- Refactor error handling

Dockerfile

@@ -18,7 +18,9 @@ ADD . .
 RUN CGO_ENABLED=0 GOOS=$(echo $TARGETPLATFORM | cut -d '/' -f1) GOARCH=$(echo $TARGETPLATFORM | cut -d '/' -f2) go build -o /blackhole
 
 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
 
 EXPOSE 8181
 

README.md

@@ -1,13 +1,29 @@
 ### GoBlackHole(with Debrid Proxy Support)
 
-This is a Golang implementation go Torrent Blackhole with a **Real Debrid Proxy Support**.
+This is a Golang implementation go Torrent QbitTorrent with a **Real Debrid & Torbox Support**.
 
-#### Uses
-- Torrent Blackhole that supports the Arrs.
+
+### Features
+
+- Mock Qbittorent API that supports the Arrs(Sonarr, Radarr, etc)
 - Proxy support for the Arrs
+- Real Debrid Support
+- Torbox Support
+- Debrid Link Support
+- Multi-Debrid Providers support
+- UI for adding torrents directly to *arrs
 
 The proxy is useful in filtering out un-cached Real Debrid torrents
 
+### Supported Debrid Providers
+- Real Debrid
+- Torbox
+- Debrid Link
+
+### Changelog
+
+- View the [CHANGELOG.md](CHANGELOG.md) for the latest changes
+
 
 #### Installation
 ##### Docker Compose
@@ -15,8 +31,11 @@ The proxy is useful in filtering out un-cached Real Debrid torrents
 version: '3.7'
 services:
   blackhole:
-    image: cy01/blackhole:latest
+    image: cy01/blackhole:latest # or cy01/blackhole:beta
     container_name: blackhole
+    ports:
+      - "8282:8282" # qBittorrent
+      - "8181:8181" # Proxy
     user: "1000:1000"
     volumes:
       - ./logs:/app/logs
@@ -27,7 +46,11 @@ services:
       - PUID=1000
       - PGID=1000
       - UMASK=002
+      - QBIT_PORT=8282 # qBittorrent Port. This is optional. You can set this in the config file
+      - PORT=8181 # Proxy Port. This is optional. You can set this in the config file
     restart: unless-stopped
+    depends_on:
+      - rclone # If you are using rclone with docker
     
 ```
 
@@ -41,44 +64,84 @@ Download the binary from the releases page and run it with the config file.
 #### Config
 ```json
 {
-  "debrid": {
-    "name": "realdebrid",
-    "host": "https://api.real-debrid.com/rest/1.0",
-    "api_key": "realdebrid_api_key",
-    "folder": "data/realdebrid/torrents/",
-    "rate_limit": "250/minute"
-  },
-  "arrs": [
+  "debrids": [
     {
-      "watch_folder": "data/sonarr/",
-      "completed_folder": "data/sonarr/completed/",
-      "token": "sonarr_api_key",
-      "url": "http://localhost:8787"
+      "name": "torbox",
+      "host": "https://api.torbox.app/v1",
+      "api_key": "torbox_api_key",
+      "folder": "data/torbox/torrents/",
+      "rate_limit": "250/minute",
+      "download_uncached": false,
+      "check_cached": true
     },
     {
-      "watch_folder": "data/radarr/",
-      "completed_folder": "data/radarr/completed/",
-      "token": "radarr_api_key",
-      "url": "http://localhost:7878"
+      "name": "realdebrid",
+      "host": "https://api.real-debrid.com/rest/1.0",
+      "api_key": "realdebrid_key",
+      "folder": "data/realdebrid/torrents/",
+      "rate_limit": "250/minute",
+      "download_uncached": false,
+      "check_cached": false
     },
     {
-      "watch_folder": "data/radarr4k/",
-      "completed_folder": "data/radarr4k/completed/",
-      "token": "radarr4k_api_key",
-      "url": "http://localhost:7878"
+      "name": "debridlink",
+      "host": "https://debrid-link.com/api/v2",
+      "api_key": "debridlink_key",
+      "folder": "data/debridlink/torrents/",
+      "rate_limit": "250/minute",
+      "download_uncached": false,
+      "check_cached": false
     }
   ],
   "proxy": {
     "enabled": true,
-    "port": "8181",
+    "port": "8100",
     "debug": false,
     "username": "username",
-    "password": "password"
+    "password": "password",
+    "cached_only": true
+  },
+  "max_cache_size": 1000,
+  "qbittorrent": {
+    "port": "8282",
+    "download_folder": "/media/symlinks/",
+    "categories": ["sonarr", "radarr"],
+    "refresh_interval": 5
   }
 }
 ```
 
-#### Proxy
+#### Config Notes
+##### 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
+
+##### Debrid Config
+- The `debrids` key is an array of debrid providers
+- The `name` key is the name of the debrid provider
+- The `host` key is the API endpoint of the debrid provider
+- The `api_key` key is the API key of the debrid provider
+- The `folder` key is the folder where the torrents will be downloaded. e.g `data/realdebrid/torrents/`
+- The `rate_limit` key is the rate limit of the debrid provider(null by default)
+- 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)
+
+##### Proxy Config
+- The `enabled` key is used to enable the proxy
+- The `port` key is the port the proxy will listen on
+- The `debug` key is used to enable debug logs
+- The `username` and `password` keys are used for basic authentication
+- The `cached_only` means only cached torrents will be returned
+
+
+##### Qbittorrent Config
+- The `port` key is the port the qBittorrent will listen on
+- The `download_folder` is the folder where the torrents will be downloaded. e.g `/media/symlinks/`
+- The `categories` key is used to filter out torrents based on the category. e.g `sonarr`, `radarr`
+- The `refresh_interval` key is used to set the interval in minutes to refresh the Arrs Monitored Downloads(it's in seconds). The default value is `5` seconds
+
+### Proxy
 
 The proxy is useful in filtering out un-cached Real Debrid torrents. 
 The proxy is a simple HTTP proxy that requires basic authentication. The proxy can be enabled by setting the `proxy.enabled` to `true` in the config file. 
@@ -94,7 +157,36 @@ Setting Up Proxy in Arr
   - Password: `password` # or the password set in the config file
   - Bypass Proxy for Local Addresses -> `No`
 
+### Qbittorrent
+
+The qBittorrent is a mock qBittorrent API that supports the Arrs(Sonarr, Radarr, etc).
+
+Setting Up Qbittorrent in Arr
+
+- Sonarr/Radarr
+  - Settings -> Download Client -> Add Client -> qBittorrent
+  - Host: `localhost` # or the IP of the server
+  - Port: `8282` # or the port set in the config file/ docker-compose env
+  - Username: `http://sonarr:8989` # Your arr host with http/https
+  - Password: `sonarr_token` # Your arr token
+  - 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
+
+### UI for adding torrents
+
+![UI](./doc/ui.png)
+
+The UI is a simple web interface that allows you to add torrents directly to the Arrs(Sonarr, Radarr, etc)
+
 ### TODO
-- [ ] Add more Debrid Providers
-- [ ] Add more Proxy features
-- [ ] Add more tests
+- [ ] A proper name!!!!
+- [ ] Debrid
+  - [ ] Add more Debrid Providers
+
+- [ ] Qbittorrent
+  - [ ] Add more Qbittorrent features
+  - [ ] Persist torrents on restart/server crash
+- [ ] Add tests

cmd/blackhole.go

@@ -1,169 +0,0 @@
-package cmd
-
-import (
-	"fmt"
-	"github.com/fsnotify/fsnotify"
-	"goBlack/common"
-	"goBlack/debrid"
-	"log"
-	"os"
-	"path/filepath"
-	"sync"
-	"time"
-)
-
-func fileReady(path string) bool {
-	_, err := os.Stat(path)
-	return !os.IsNotExist(err) // Returns true if the file exists
-}
-
-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 fileReady(path) {
-				ready <- file
-				return
-			}
-		}
-	}
-}
-
-func ProcessFiles(arr *debrid.Arr, torrent *debrid.Torrent) {
-	var wg sync.WaitGroup
-	files := torrent.Files
-	ready := make(chan debrid.TorrentFile, len(files))
-
-	log.Println("Checking files...")
-
-	for _, file := range files {
-		wg.Add(1)
-		go checkFileLoop(&wg, arr.Debrid.Folder, file, ready)
-	}
-
-	go func() {
-		wg.Wait()
-		close(ready)
-	}()
-
-	for r := range ready {
-		log.Println("File is ready:", r.Name)
-		CreateSymLink(arr, torrent)
-
-	}
-	go torrent.Cleanup(true)
-	fmt.Printf("%s downloaded", torrent.Name)
-}
-
-func CreateSymLink(config *debrid.Arr, torrent *debrid.Torrent) {
-	path := filepath.Join(config.CompletedFolder, torrent.Folder)
-	err := os.MkdirAll(path, os.ModePerm)
-	if err != nil {
-		log.Printf("Failed to create directory: %s\n", path)
-	}
-	for _, file := range torrent.Files {
-		// Combine the directory and filename to form a full path
-		fullPath := filepath.Join(config.CompletedFolder, file.Path)
-
-		// Create a symbolic link if file doesn't exist
-		_ = os.Symlink(filepath.Join(config.Debrid.Folder, file.Path), fullPath)
-	}
-}
-
-func watchFiles(watcher *fsnotify.Watcher, events map[string]time.Time) {
-	for {
-		select {
-		case event, ok := <-watcher.Events:
-			if !ok {
-				return
-			}
-			if event.Op&fsnotify.Write == fsnotify.Write {
-				if filepath.Ext(event.Name) == ".torrent" || filepath.Ext(event.Name) == ".magnet" {
-					events[event.Name] = time.Now()
-				}
-
-			}
-		case err, ok := <-watcher.Errors:
-			if !ok {
-				return
-			}
-			log.Println("ERROR:", err)
-		}
-	}
-}
-
-func processFilesDebounced(arr *debrid.Arr, db debrid.Service, events map[string]time.Time, debouncePeriod time.Duration) {
-	ticker := time.NewTicker(1 * time.Second) // Check every second
-	defer ticker.Stop()
-
-	for range ticker.C {
-		for file, lastEventTime := range events {
-			if time.Since(lastEventTime) >= debouncePeriod {
-				log.Printf("Torrent file detected: %s", file)
-				// Process the torrent file
-				torrent, err := db.Process(arr, file)
-				if err != nil && torrent != nil {
-					// remove torrent file
-					torrent.Cleanup(true)
-					_ = torrent.MarkAsFailed()
-					log.Printf("Error processing torrent file: %s", err)
-				}
-				if err == nil && torrent != nil && len(torrent.Files) > 0 {
-					go ProcessFiles(arr, torrent)
-				}
-				delete(events, file) // remove file from channel
-
-			}
-		}
-	}
-}
-
-func StartArr(conf *debrid.Arr, db debrid.Service) {
-	log.Printf("Watching: %s", conf.WatchFolder)
-	w, err := fsnotify.NewWatcher()
-	if err != nil {
-		log.Println(err)
-	}
-	defer func(w *fsnotify.Watcher) {
-		err := w.Close()
-		if err != nil {
-			log.Println(err)
-		}
-	}(w)
-	events := make(map[string]time.Time)
-
-	go watchFiles(w, events)
-	if err = w.Add(conf.WatchFolder); err != nil {
-		log.Println("Error Watching folder:", err)
-		return
-	}
-
-	processFilesDebounced(conf, db, events, 1*time.Second)
-}
-
-func StartBlackhole(config *common.Config, deb debrid.Service) {
-	var wg sync.WaitGroup
-	for _, conf := range config.Arrs {
-		wg.Add(1)
-		defer wg.Done()
-		headers := map[string]string{
-			"X-Api-Key": conf.Token,
-		}
-		client := common.NewRLHTTPClient(nil, headers)
-
-		arr := &debrid.Arr{
-			Debrid:          config.Debrid,
-			WatchFolder:     conf.WatchFolder,
-			CompletedFolder: conf.CompletedFolder,
-			Token:           conf.Token,
-			URL:             conf.URL,
-			Client:          client,
-		}
-		go StartArr(arr, deb)
-	}
-	wg.Wait()
-}

cmd/main.go

@@ -1,18 +1,53 @@
 package cmd
 
 import (
+	"cmp"
+	"context"
 	"goBlack/common"
-	"goBlack/debrid"
-	"log"
+	"goBlack/pkg/debrid"
+	"goBlack/pkg/proxy"
+	"goBlack/pkg/qbit"
+	"sync"
 )
 
-func Start(config *common.Config) {
+func Start(ctx context.Context, config *common.Config) error {
+	maxCacheSize := cmp.Or(config.MaxCacheSize, 1000)
+	cache := common.NewCache(maxCacheSize)
+
+	deb := debrid.NewDebrid(config.Debrids, cache)
+
+	var wg sync.WaitGroup
+	errChan := make(chan error, 2)
 
-	log.Print("[*] BlackHole running")
-	deb := debrid.NewDebrid(config.Debrid)
 	if config.Proxy.Enabled {
-		go StartProxy(config, deb)
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			if err := proxy.NewProxy(*config, deb, cache).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, cache); err != nil {
+				errChan <- err
+			}
+		}()
 	}
-	StartBlackhole(config, deb)
 
+	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/proxy.go

@@ -1,272 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"cmp"
-	"encoding/xml"
-	"fmt"
-	"github.com/elazarl/goproxy"
-	"github.com/elazarl/goproxy/ext/auth"
-	"github.com/valyala/fastjson"
-	"goBlack/common"
-	"goBlack/debrid"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"regexp"
-	"strings"
-	"sync"
-)
-
-type RSS struct {
-	XMLName xml.Name `xml:"rss"`
-	Version string   `xml:"version,attr"`
-	Channel Channel  `xml:"channel"`
-}
-
-type Channel struct {
-	XMLName  xml.Name `xml:"channel"`
-	Title    string   `xml:"title"`
-	AtomLink AtomLink `xml:"link"`
-	Items    []Item   `xml:"item"`
-}
-
-type AtomLink struct {
-	XMLName xml.Name `xml:"link"`
-	Rel     string   `xml:"rel,attr"`
-	Type    string   `xml:"type,attr"`
-}
-
-type Item struct {
-	XMLName         xml.Name        `xml:"item"`
-	Title           string          `xml:"title"`
-	Description     string          `xml:"description"`
-	GUID            string          `xml:"guid"`
-	ProwlarrIndexer ProwlarrIndexer `xml:"prowlarrindexer"`
-	Comments        string          `xml:"comments"`
-	PubDate         string          `xml:"pubDate"`
-	Size            int64           `xml:"size"`
-	Link            string          `xml:"link"`
-	Categories      []string        `xml:"category"`
-	Enclosure       Enclosure       `xml:"enclosure"`
-	TorznabAttrs    []TorznabAttr   `xml:"torznab:attr"`
-}
-
-type ProwlarrIndexer struct {
-	ID    string `xml:"id,attr"`
-	Type  string `xml:"type,attr"`
-	Value string `xml:",chardata"`
-}
-
-type Enclosure struct {
-	URL    string `xml:"url,attr"`
-	Length int64  `xml:"length,attr"`
-	Type   string `xml:"type,attr"`
-}
-
-type TorznabAttr struct {
-	Name  string `xml:"name,attr"`
-	Value string `xml:"value,attr"`
-}
-
-type SafeItems struct {
-	mu    sync.Mutex
-	Items []Item
-}
-
-func (s *SafeItems) Add(item Item) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	s.Items = append(s.Items, item)
-}
-
-func (s *SafeItems) Get() []Item {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	return s.Items
-}
-
-func ProcessJSONResponse(resp *http.Response, deb debrid.Service) *http.Response {
-	if resp == nil || resp.Body == nil {
-		return resp
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Println("Error reading response body:", err)
-		return resp
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return nil
-	}
-
-	var p fastjson.Parser
-	v, err := p.ParseBytes(body)
-	if err != nil {
-		// If it's not JSON, return the original response
-		resp.Body = io.NopCloser(bytes.NewReader(body))
-		return resp
-	}
-
-	// Modify the JSON
-
-	// Serialize the modified JSON back to bytes
-	modifiedBody := v.MarshalTo(nil)
-
-	// Set the modified body back to the response
-	resp.Body = io.NopCloser(bytes.NewReader(modifiedBody))
-	resp.ContentLength = int64(len(modifiedBody))
-	resp.Header.Set("Content-Length", string(rune(len(modifiedBody))))
-
-	return resp
-
-}
-
-func ProcessResponse(resp *http.Response, deb debrid.Service) *http.Response {
-	if resp == nil || resp.Body == nil {
-		return resp
-	}
-	contentType := resp.Header.Get("Content-Type")
-	switch contentType {
-	case "application/json":
-		return ProcessJSONResponse(resp, deb)
-	case "application/xml":
-		return ProcessXMLResponse(resp, deb)
-	case "application/rss+xml":
-		return ProcessXMLResponse(resp, deb)
-	default:
-		return resp
-	}
-}
-
-func XMLItemIsCached(item Item, deb debrid.Service) bool {
-	magnetLink := ""
-	infohash := ""
-
-	// Extract magnet link from the link or comments
-	if strings.Contains(item.Link, "magnet:?") {
-		magnetLink = item.Link
-	} else if strings.Contains(item.GUID, "magnet:?") {
-		magnetLink = item.GUID
-	}
-
-	// Extract infohash from <torznab:attr> elements
-	for _, attr := range item.TorznabAttrs {
-		if attr.Name == "infohash" {
-			infohash = attr.Value
-		}
-	}
-	if magnetLink == "" && infohash == "" {
-		// We can't check the availability of the torrent without a magnet link or infohash
-		return false
-	}
-	var magnet *common.Magnet
-	var err error
-
-	if infohash == "" {
-		magnet, err = common.GetMagnetInfo(magnetLink)
-		if err != nil {
-			log.Println("Error getting magnet info:", err)
-			return false
-		}
-	} else {
-		magnet = &common.Magnet{
-			InfoHash: infohash,
-			Name:     item.Title,
-			Link:     magnetLink,
-		}
-	}
-	if magnet == nil {
-		log.Println("Error getting magnet info")
-		return false
-	}
-	return deb.IsAvailable(magnet)
-
-}
-
-func ProcessXMLResponse(resp *http.Response, deb debrid.Service) *http.Response {
-	if resp == nil || resp.Body == nil {
-		return resp
-	}
-
-	body, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Println("Error reading response body:", err)
-		return resp
-	}
-	err = resp.Body.Close()
-	if err != nil {
-		return nil
-	}
-
-	var rss RSS
-	err = xml.Unmarshal(body, &rss)
-	if err != nil {
-		log.Printf("Error unmarshalling XML: %v", err)
-		return resp
-	}
-	newItems := &SafeItems{}
-	var wg sync.WaitGroup
-
-	// Step 4: Extract infohash or magnet URI, manipulate data
-	for _, item := range rss.Channel.Items {
-		wg.Add(1)
-		go func(item Item) {
-			defer wg.Done()
-			if XMLItemIsCached(item, deb) {
-				newItems.Add(item)
-			}
-		}(item)
-	}
-	wg.Wait()
-	items := newItems.Get()
-	log.Printf("Report: %d/%d items are cached", len(items), len(rss.Channel.Items))
-	rss.Channel.Items = items
-
-	// rss.Channel.Items = newItems
-	modifiedBody, err := xml.MarshalIndent(rss, "", "  ")
-	if err != nil {
-		log.Printf("Error marshalling XML: %v", err)
-		return resp
-	}
-	modifiedBody = append([]byte(xml.Header), modifiedBody...)
-
-	// Set the modified body back to the response
-	resp.Body = io.NopCloser(bytes.NewReader(modifiedBody))
-	resp.ContentLength = int64(len(modifiedBody))
-	resp.Header.Set("Content-Length", string(rune(len(modifiedBody))))
-
-	return resp
-}
-
-func UrlMatches(re *regexp.Regexp) goproxy.ReqConditionFunc {
-	return func(req *http.Request, ctx *goproxy.ProxyCtx) bool {
-		return re.MatchString(req.URL.String())
-	}
-}
-
-func StartProxy(config *common.Config, deb debrid.Service) {
-	username, password := config.Proxy.Username, config.Proxy.Password
-	cfg := config.Proxy
-	proxy := goproxy.NewProxyHttpServer()
-	if username != "" || password != "" {
-		// Set up basic auth for proxy
-		auth.ProxyBasic(proxy, "my_realm", func(user, pwd string) bool {
-			return user == username && password == pwd
-		})
-	}
-
-	proxy.OnRequest(goproxy.ReqHostMatches(regexp.MustCompile("^.443$"))).HandleConnect(goproxy.AlwaysMitm)
-	proxy.OnResponse(UrlMatches(regexp.MustCompile("^.*/api\\?t=(search|tvsearch|movie)(&.*)?$"))).DoFunc(
-		func(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
-			return ProcessResponse(resp, deb)
-		})
-
-	port := cmp.Or(os.Getenv("PORT"), cfg.Port, "8181")
-	proxy.Verbose = cfg.Debug
-	port = fmt.Sprintf(":%s", port)
-	log.Printf("Starting proxy server on %s\n", port)
-	log.Fatal(http.ListenAndServe(fmt.Sprintf("%s", port), proxy))
-}

common/cache.go

@@ -0,0 +1,88 @@
+package common
+
+import (
+	"sync"
+)
+
+type Cache struct {
+	data     map[string]struct{}
+	order    []string
+	maxItems int
+	mu       sync.RWMutex
+}
+
+func NewCache(maxItems int) *Cache {
+	if maxItems <= 0 {
+		maxItems = 1000
+	}
+	return &Cache{
+		data:     make(map[string]struct{}, maxItems),
+		order:    make([]string, 0, maxItems),
+		maxItems: maxItems,
+	}
+}
+
+func (c *Cache) Add(value string) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if _, exists := c.data[value]; !exists {
+		if len(c.order) >= c.maxItems {
+			delete(c.data, c.order[0])
+			c.order = c.order[1:]
+		}
+		c.data[value] = struct{}{}
+		c.order = append(c.order, value)
+	}
+}
+
+func (c *Cache) AddMultiple(values map[string]bool) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	for value := range values {
+		if _, exists := c.data[value]; !exists {
+			if len(c.order) >= c.maxItems {
+				delete(c.data, c.order[0])
+				c.order = c.order[1:]
+			}
+			c.data[value] = struct{}{}
+			c.order = append(c.order, value)
+		}
+	}
+}
+
+func (c *Cache) Get(index int) (string, bool) {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	if index < 0 || index >= len(c.order) {
+		return "", false
+	}
+	return c.order[index], true
+}
+
+func (c *Cache) GetMultiple(values []string) map[string]bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+
+	result := make(map[string]bool, len(values))
+	for _, value := range values {
+		if _, exists := c.data[value]; exists {
+			result[value] = true
+		}
+	}
+	return result
+}
+
+func (c *Cache) Exists(value string) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	_, exists := c.data[value]
+	return exists
+}
+
+func (c *Cache) Len() int {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	return len(c.order)
+}

common/config.go

@@ -2,8 +2,11 @@ package common
 
 import (
 	"encoding/json"
+	"errors"
+	"fmt"
 	"log"
 	"os"
+	"sync"
 )
 
 type DebridConfig struct {
@@ -12,25 +15,111 @@ type DebridConfig struct {
 	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"`
+	Debug      bool   `json:"debug"`
+	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"`
+	Debug           bool     `json:"debug"`
+	DownloadFolder  string   `json:"download_folder"`
+	Categories      []string `json:"categories"`
+	RefreshInterval int      `json:"refresh_interval"`
+}
+
 type Config struct {
-	DbDSN  string       `json:"db_dsn"`
-	Debrid DebridConfig `json:"debrid"`
-	Arrs   []struct {
-		WatchFolder     string `json:"watch_folder"`
-		CompletedFolder string `json:"completed_folder"`
-		Token           string `json:"token"`
-		URL             string `json:"url"`
-	} `json:"arrs"`
-	Proxy struct {
-		Port     string `json:"port"`
-		Enabled  bool   `json:"enabled"`
-		Debug    bool   `json:"debug"`
-		Username string `json:"username"`
-		Password string `json:"password"`
+	Debrid       DebridConfig      `json:"debrid"`
+	Debrids      []DebridConfig    `json:"debrids"`
+	Proxy        ProxyConfig       `json:"proxy"`
+	MaxCacheSize int               `json:"max_cache_size"`
+	QBitTorrent  QBitTorrentConfig `json:"qbittorrent"`
+}
+
+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) {
@@ -53,5 +142,14 @@ func LoadConfig(path string) (*Config, error) {
 		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
 }

common/logger.go

@@ -0,0 +1,14 @@
+package common
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+func NewLogger(prefix string, output *os.File) *log.Logger {
+	f := fmt.Sprintf("[%s] ", prefix)
+	return log.New(output, f, log.LstdFlags)
+}
+
+var Logger = NewLogger("Main", os.Stdout)

common/regex.go

@@ -1,12 +1,16 @@
 package common
 
 import (
+	"path/filepath"
 	"regexp"
+	"strings"
 )
 
 var (
-	VIDEOMATCH = "(?i)(\\.)(YUV|WMV|WEBM|VOB|VIV|SVI|ROQ|RMVB|RM|OGV|OGG|NSV|MXF|MTS|M2TS|TS|MPG|MPEG|M2V|MP2|MPE|MPV|MP4|M4P|M4V|MOV|QT|MNG|MKV|FLV|DRC|AVI|ASF|AMV)$"
-	SUBMATCH   = "(?i)(\\.)(SRT|SUB|SBV|ASS|VTT|TTML|DFXP|STL|SCC|CAP|SMI|TTXT|TDS|USF|JSS|SSA|PSB|RT|LRC|SSB)$"
+	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 {
@@ -14,8 +18,26 @@ func RegexMatch(regex string, value string) bool {
 	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)
+	re := regexp.MustCompile(VIDEOMATCH + "|" + SUBMATCH + "|" + SAMPLEMATCH + "|" + MUSICMATCH)
 
 	// Find the last index of the matched extension
 	loc := re.FindStringIndex(value)
@@ -25,3 +47,13 @@ func RemoveExtension(value string) string {
 		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 ""
+	}
+}

common/request.go

@@ -2,6 +2,7 @@ package common
 
 import (
 	"crypto/tls"
+	"encoding/json"
 	"fmt"
 	"golang.org/x/time/rate"
 	"io"
@@ -60,11 +61,7 @@ func (c *RLHTTPClient) Do(req *http.Request) (*http.Response, error) {
 	return resp, fmt.Errorf("max retries exceeded")
 }
 
-func (c *RLHTTPClient) MakeRequest(method string, url string, body io.Reader) ([]byte, error) {
-	req, err := http.NewRequest(method, url, body)
-	if err != nil {
-		return nil, err
-	}
+func (c *RLHTTPClient) MakeRequest(req *http.Request) ([]byte, error) {
 	if c.Headers != nil {
 		for key, value := range c.Headers {
 			req.Header.Set(key, value)
@@ -75,9 +72,12 @@ func (c *RLHTTPClient) MakeRequest(method string, url string, body io.Reader) ([
 	if err != nil {
 		return nil, err
 	}
+	b, _ := io.ReadAll(res.Body)
 	statusOk := strconv.Itoa(res.StatusCode)[0] == '2'
 	if !statusOk {
-		return nil, fmt.Errorf("unexpected status code: %d", res.StatusCode)
+		// 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()
@@ -85,7 +85,7 @@ func (c *RLHTTPClient) MakeRequest(method string, url string, body io.Reader) ([
 			log.Println(err)
 		}
 	}(res.Body)
-	return io.ReadAll(res.Body)
+	return b, nil
 }
 
 func NewRLHTTPClient(rl *rate.Limiter, headers map[string]string) *RLHTTPClient {
@@ -128,3 +128,9 @@ func ParseRateLimit(rateStr string) *rate.Limiter {
 		return nil
 	}
 }
+
+func JSONResponse(w http.ResponseWriter, data interface{}, code int) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(code)
+	json.NewEncoder(w).Encode(data)
+}

common/utils.go

@@ -2,12 +2,22 @@ package common
 
 import (
 	"bufio"
+	"context"
+	"encoding/base32"
+	"encoding/hex"
 	"fmt"
+	"github.com/anacrolix/torrent/metainfo"
+	"io"
 	"log"
 	"math/rand"
+	"net/http"
 	"net/url"
 	"os"
+	"path"
+	"path/filepath"
+	"regexp"
 	"strings"
+	"time"
 )
 
 type Magnet struct {
@@ -17,6 +27,41 @@ type Magnet struct {
 	Link     string
 }
 
+func GetMagnetFromFile(file io.Reader, filePath string) (*Magnet, error) {
+	if filepath.Ext(filePath) == ".torrent" {
+		mi, err := metainfo.Load(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
+	} else {
+		// .magnet file
+		magnetLink := ReadMagnetFile(file)
+		return GetMagnetInfo(magnetLink)
+	}
+}
+
+func GetMagnetFromUrl(url string) (*Magnet, error) {
+	if strings.HasPrefix(url, "magnet:") {
+		return GetMagnetInfo(url)
+	} else if strings.HasPrefix(url, "http") {
+		return OpenMagnetHttpURL(url)
+	}
+	return nil, fmt.Errorf("invalid url")
+}
+
 func OpenMagnetFile(filePath string) string {
 	file, err := os.Open(filePath)
 	if err != nil {
@@ -29,13 +74,15 @@ func OpenMagnetFile(filePath string) string {
 			return
 		}
 	}(file) // Ensure the file is closed after the function ends
+	return ReadMagnetFile(file)
+}
 
-	// Create a scanner to read the file line by line
+func ReadMagnetFile(file io.Reader) string {
 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
-		magnetLink := scanner.Text()
-		if magnetLink != "" {
-			return magnetLink
+		content := scanner.Text()
+		if content != "" {
+			return content
 		}
 	}
 
@@ -46,14 +93,50 @@ func OpenMagnetFile(filePath string) string {
 	return ""
 }
 
+func OpenMagnetHttpURL(magnetLink string) (*Magnet, error) {
+	resp, err := http.Get(magnetLink)
+	if err != nil {
+		return nil, fmt.Errorf("error making GET request: %v", err)
+	}
+	defer func(resp *http.Response) {
+		err := resp.Body.Close()
+		if err != nil {
+			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)
+	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 GetMagnetInfo(magnetLink string) (*Magnet, error) {
 	if magnetLink == "" {
 		return nil, fmt.Errorf("error getting magnet from file")
 	}
+
 	magnetURI, err := url.Parse(magnetLink)
 	if err != nil {
 		return nil, fmt.Errorf("error parsing magnet link")
 	}
+
 	query := magnetURI.Query()
 	xt := query.Get("xt")
 	dn := query.Get("dn")
@@ -81,3 +164,107 @@ func RandomString(length int) string {
 	}
 	return string(b)
 }
+
+func ExtractInfoHash(magnetDesc string) string {
+	const prefix = "xt=urn:btih:"
+	start := strings.Index(magnetDesc, prefix)
+	if start == -1 {
+		return ""
+	}
+	hash := ""
+	start += len(prefix)
+	end := strings.IndexAny(magnetDesc[start:], "&#")
+	if end == -1 {
+		hash = magnetDesc[start:]
+	} else {
+		hash = magnetDesc[start : start+end]
+	}
+	hash, _ = processInfoHash(hash) // Convert to hex if needed
+	return hash
+}
+
+func processInfoHash(input string) (string, error) {
+	// Regular expression for a valid 40-character hex infohash
+	hexRegex := regexp.MustCompile("^[0-9a-fA-F]{40}$")
+
+	// If it's already a valid hex infohash, return it as is
+	if hexRegex.MatchString(input) {
+		return strings.ToLower(input), nil
+	}
+
+	// If it's 32 characters long, it might be Base32 encoded
+	if len(input) == 32 {
+		// Ensure the input is uppercase and remove any padding
+		input = strings.ToUpper(strings.TrimRight(input, "="))
+
+		// Try to decode from Base32
+		decoded, err := base32.StdEncoding.DecodeString(input)
+		if err == nil && len(decoded) == 20 {
+			// If successful and the result is 20 bytes, encode to hex
+			return hex.EncodeToString(decoded), nil
+		}
+	}
+
+	// If we get here, it's not a valid infohash and we couldn't convert it
+	return "", fmt.Errorf("invalid infohash: %s", input)
+}
+
+func GetInfohashFromURL(url string) (string, error) {
+	// Download the torrent file
+	var magnetLink string
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			if len(via) >= 3 {
+				return fmt.Errorf("stopped after 3 redirects")
+			}
+			if strings.HasPrefix(req.URL.String(), "magnet:") {
+				// Stop the redirect chain
+				magnetLink = req.URL.String()
+				return http.ErrUseLastResponse
+			}
+			return nil
+		},
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	if err != nil {
+		return "", err
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+	if magnetLink != "" {
+		return ExtractInfoHash(magnetLink), nil
+	}
+
+	mi, err := metainfo.Load(resp.Body)
+	if err != nil {
+		return "", err
+	}
+	hash := mi.HashInfoBytes()
+	infoHash := hash.HexString()
+	return infoHash, nil
+}
+
+func JoinURL(base string, paths ...string) (string, error) {
+	// Parse the base URL
+	u, err := url.Parse(base)
+	if err != nil {
+		return "", err
+	}
+
+	// Join the path components
+	u.Path = path.Join(u.Path, path.Join(paths...))
+
+	// Return the resulting URL as a string
+	return u.String(), nil
+}
+
+func FileReady(path string) bool {
+	_, err := os.Stat(path)
+	return !os.IsNotExist(err) // Returns true if the file exists
+}

debrid/debrid.go

@@ -1,83 +0,0 @@
-package debrid
-
-import (
-	"github.com/anacrolix/torrent/metainfo"
-	"goBlack/common"
-	"path/filepath"
-)
-
-type Service interface {
-	SubmitMagnet(torrent *Torrent) (*Torrent, error)
-	CheckStatus(torrent *Torrent) (*Torrent, error)
-	DownloadLink(torrent *Torrent) error
-	Process(arr *Arr, magnet string) (*Torrent, error)
-	IsAvailable(magnet *common.Magnet) bool
-}
-
-type Debrid struct {
-	Host             string `json:"host"`
-	APIKey           string
-	DownloadUncached bool
-}
-
-func NewDebrid(dc common.DebridConfig) Service {
-	switch dc.Name {
-	case "realdebrid":
-		return NewRealDebrid(dc)
-	default:
-		return NewRealDebrid(dc)
-	}
-}
-
-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
-	}
-	magnet := &common.Magnet{
-		InfoHash: infoHash,
-		Name:     info.Name,
-		Size:     info.Length,
-		Link:     mi.Magnet(&hash, &info).String(),
-	}
-	torrent := &Torrent{
-		InfoHash: infoHash,
-		Name:     info.Name,
-		Size:     info.Length,
-		Magnet:   magnet,
-		Filename: filePath,
-	}
-	return torrent, nil
-}

debrid/realdebrid.go

@@ -1,155 +0,0 @@
-package debrid
-
-import (
-	"encoding/json"
-	"fmt"
-	"goBlack/common"
-	"goBlack/debrid/structs"
-	"log"
-	"net/http"
-	gourl "net/url"
-	"path/filepath"
-	"strconv"
-	"strings"
-)
-
-type RealDebrid struct {
-	Host             string `json:"host"`
-	APIKey           string
-	DownloadUncached bool
-	client           *common.RLHTTPClient
-}
-
-func (r *RealDebrid) Process(arr *Arr, magnet string) (*Torrent, error) {
-	torrent, err := GetTorrentInfo(magnet)
-	torrent.Arr = arr
-	if err != nil {
-		return torrent, err
-	}
-	log.Printf("Torrent Name: %s", torrent.Name)
-	if !r.DownloadUncached {
-		if !r.IsAvailable(torrent.Magnet) {
-			return torrent, fmt.Errorf("torrent is not cached")
-		}
-		log.Printf("Torrent: %s is cached", torrent.Name)
-	}
-
-	torrent, err = r.SubmitMagnet(torrent)
-	if err != nil || torrent.Id == "" {
-		return nil, err
-	}
-	return r.CheckStatus(torrent)
-}
-
-func (r *RealDebrid) IsAvailable(magnet *common.Magnet) bool {
-	url := fmt.Sprintf("%s/torrents/instantAvailability/%s", r.Host, magnet.InfoHash)
-	resp, err := r.client.MakeRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return false
-	}
-	var data structs.RealDebridAvailabilityResponse
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return false
-	}
-	hosters, exists := data[strings.ToLower(magnet.InfoHash)]
-	if !exists || len(hosters) < 1 {
-		return false
-	}
-	return true
-}
-
-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
-	resp, err := r.client.MakeRequest(http.MethodPost, url, strings.NewReader(payload.Encode()))
-	if err != nil {
-		return nil, err
-	}
-	err = json.Unmarshal(resp, &data)
-	log.Printf("Torrent: %s added with id: %s\n", torrent.Name, data.Id)
-	torrent.Id = data.Id
-
-	return torrent, nil
-}
-
-func (r *RealDebrid) CheckStatus(torrent *Torrent) (*Torrent, error) {
-	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, torrent.Id)
-	for {
-		resp, err := r.client.MakeRequest(http.MethodGet, url, nil)
-		if err != nil {
-			return torrent, err
-		}
-		var data structs.RealDebridTorrentInfo
-		err = json.Unmarshal(resp, &data)
-		status := data.Status
-		torrent.Folder = common.RemoveExtension(data.OriginalFilename)
-		if status == "error" || status == "dead" || status == "magnet_error" {
-			return torrent, fmt.Errorf("torrent: %s has error", torrent.Name)
-		} else if status == "waiting_files_selection" {
-			files := make([]TorrentFile, 0)
-			for _, f := range data.Files {
-				name := f.Path
-				if !common.RegexMatch(common.VIDEOMATCH, name) && !common.RegexMatch(common.SUBMATCH, name) {
-					continue
-				}
-				fileId := f.ID
-				file := &TorrentFile{
-					Name: name,
-					Path: filepath.Join(torrent.Folder, name),
-					Size: int64(f.Bytes),
-					Id:   strconv.Itoa(fileId),
-				}
-				files = append(files, *file)
-			}
-			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())
-			_, err = r.client.MakeRequest(http.MethodPost, fmt.Sprintf("%s/torrents/selectFiles/%s", r.Host, torrent.Id), payload)
-			if err != nil {
-				return torrent, err
-			}
-		} else if status == "downloaded" {
-			log.Printf("Torrent: %s downloaded\n", torrent.Name)
-			err = r.DownloadLink(torrent)
-			if err != nil {
-				return torrent, err
-			}
-			break
-		} else if status == "downloading" {
-			return torrent, fmt.Errorf("torrent is uncached")
-		}
-
-	}
-	return torrent, nil
-}
-
-func (r *RealDebrid) DownloadLink(torrent *Torrent) error {
-	return nil
-}
-
-func NewRealDebrid(dc common.DebridConfig) *RealDebrid {
-	rl := common.ParseRateLimit(dc.RateLimit)
-	headers := map[string]string{
-		"Authorization": fmt.Sprintf("Bearer %s", dc.APIKey),
-	}
-	client := common.NewRLHTTPClient(rl, headers)
-	return &RealDebrid{
-		Host:             dc.Host,
-		APIKey:           dc.APIKey,
-		DownloadUncached: dc.DownloadUncached,
-		client:           client,
-	}
-}

debrid/structs/realdebrid.go

@@ -1,41 +0,0 @@
-package structs
-
-type RealDebridAvailabilityResponse map[string]Hosters
-
-type Hosters map[string][]FileIDs
-
-type FileIDs map[string]FileVariant
-
-type FileVariant struct {
-	Filename string `json:"filename"`
-	Filesize int    `json:"filesize"`
-}
-
-type RealDebridAddMagnetSchema struct {
-	Id  string `json:"id"`
-	Uri string `json:"uri"`
-}
-
-type RealDebridTorrentInfo struct {
-	ID               string `json:"id"`
-	Filename         string `json:"filename"`
-	OriginalFilename string `json:"original_filename"`
-	Hash             string `json:"hash"`
-	Bytes            int    `json:"bytes"`
-	OriginalBytes    int    `json:"original_bytes"`
-	Host             string `json:"host"`
-	Split            int    `json:"split"`
-	Progress         int    `json:"progress"`
-	Status           string `json:"status"`
-	Added            string `json:"added"`
-	Files            []struct {
-		ID       int    `json:"id"`
-		Path     string `json:"path"`
-		Bytes    int    `json:"bytes"`
-		Selected int    `json:"selected"`
-	} `json:"files"`
-	Links   []string `json:"links"`
-	Ended   string   `json:"ended,omitempty"`
-	Speed   int      `json:"speed,omitempty"`
-	Seeders int      `json:"seeders,omitempty"`
-}

debrid/torrent.go

@@ -1,142 +0,0 @@
-package debrid
-
-import (
-	"encoding/json"
-	"goBlack/common"
-	"log"
-	"net/http"
-	gourl "net/url"
-	"os"
-	"strconv"
-	"strings"
-)
-
-type Arr struct {
-	WatchFolder     string              `json:"watch_folder"`
-	CompletedFolder string              `json:"completed_folder"`
-	Debrid          common.DebridConfig `json:"debrid"`
-	Token           string              `json:"token"`
-	URL             string              `json:"url"`
-	Client          *common.RLHTTPClient
-}
-
-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"`
-	Size     int64          `json:"size"`
-	Magnet   *common.Magnet `json:"magnet"`
-	Files    []TorrentFile  `json:"files"`
-	Status   string         `json:"status"`
-
-	Arr *Arr
-}
-
-type TorrentFile struct {
-	Id   string `json:"id"`
-	Name string `json:"name"`
-	Size int64  `json:"size"`
-	Path string `json:"path"`
-}
-
-func (arr *Arr) GetHeaders() map[string]string {
-	return map[string]string{
-		"X-Api-Key": arr.Token,
-	}
-}
-
-func (arr *Arr) GetURL() string {
-	url, _ := gourl.JoinPath(arr.URL, "api/v3/")
-	return url
-}
-
-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 (arr *Arr) GetHistory(downloadId, eventType string) *ArrHistorySchema {
-	eventId := getEventId(eventType)
-	query := gourl.Values{}
-	if downloadId != "" {
-		query.Add("downloadId", downloadId)
-	}
-	if eventId != 0 {
-		query.Add("eventId", strconv.Itoa(eventId))
-
-	}
-	query.Add("pageSize", "100")
-	url := arr.GetURL() + "history/" + "?" + query.Encode()
-	resp, err := arr.Client.MakeRequest(http.MethodGet, url, nil)
-	if err != nil {
-		return nil
-	}
-	var data *ArrHistorySchema
-	err = json.Unmarshal(resp, &data)
-	if err != nil {
-		return nil
-	}
-	return data
-
-}
-
-func (t *Torrent) Cleanup(remove bool) {
-	if remove {
-		err := os.Remove(t.Filename)
-		if err != nil {
-			return
-		}
-	}
-}
-
-func (t *Torrent) MarkAsFailed() error {
-	downloadId := strings.ToUpper(t.Magnet.InfoHash)
-	history := t.Arr.GetHistory(downloadId, "grabbed")
-	if history == nil {
-		return nil
-	}
-	torrentId := 0
-	for _, record := range history.Records {
-		if strings.EqualFold(record.DownloadID, downloadId) {
-			torrentId = record.ID
-			break
-		}
-	}
-	if torrentId != 0 {
-		url, err := gourl.JoinPath(t.Arr.GetURL(), "history/failed/", strconv.Itoa(torrentId))
-		if err != nil {
-			return err
-		}
-		_, err = t.Arr.Client.MakeRequest(http.MethodPost, url, nil)
-		if err == nil {
-			log.Printf("Marked torrent: %s as failed", t.Name)
-		}
-	}
-	return nil
-}

go.mod

@@ -4,9 +4,12 @@ go 1.22
 
 require (
 	github.com/anacrolix/torrent v1.55.0
+	github.com/cavaliergopher/grab/v3 v3.0.1
 	github.com/elazarl/goproxy v0.0.0-20240726154733-8b0c20506380
 	github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2
-	github.com/fsnotify/fsnotify v1.7.0
+	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/valyala/fastjson v1.6.4
 	golang.org/x/time v0.6.0
 )
@@ -14,10 +17,12 @@ require (
 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/google/go-cmp v0.6.0 // indirect
 	github.com/huandu/xstrings v1.3.2 // indirect
+	github.com/klauspost/compress v1.17.9 // 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
 )

go.sum

@@ -35,6 +35,8 @@ 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=
@@ -44,6 +46,8 @@ github.com/bradfitz/iter v0.0.0-20140124041915-454541ec3da2/go.mod h1:PyRFw1Lt2w
 github.com/bradfitz/iter v0.0.0-20190303215204-33e6a9893b0c/go.mod h1:PyRFw1Lt2wKX4ZVSQ2mk+PeDa1rxyObEDlApuIsUKuo=
 github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 h1:GKTyiRCL6zVf5wWaqKnf+7Qs6GbEPfd4iMOitWzXJx8=
 github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8/go.mod h1:spo1JLcs67NmW1aVLEgtA8Yy1elc+X8y5SRW1sFW4Og=
+github.com/cavaliergopher/grab/v3 v3.0.1 h1:4z7TkBfmPjmLAAmkkAZNX/6QJ1nNFdv3SdIHXju0Fr4=
+github.com/cavaliergopher/grab/v3 v3.0.1/go.mod h1:1U/KNnD+Ft6JJiYoYBAimKH2XrYptb8Kl3DFGmsjpq4=
 github.com/cespare/xxhash/v2 v2.1.1/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
@@ -62,14 +66,14 @@ github.com/elazarl/goproxy/ext v0.0.0-20190711103511-473e67f1d7d2/go.mod h1:gNh8
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
 github.com/frankban/quicktest v1.14.6/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
-github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
-github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/glycerine/go-unsnap-stream v0.0.0-20180323001048-9f0cb55181dd/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
 github.com/glycerine/go-unsnap-stream v0.0.0-20181221182339-f9677308dec2/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
 github.com/glycerine/go-unsnap-stream v0.0.0-20190901134440-81cf024a9e0a/go.mod h1:/20jfyN9Y5QPEAprSgKAUr+glWDY39ZiUEAYOEv5dsE=
 github.com/glycerine/goconvey v0.0.0-20180728074245-46e3a41ad493/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
 github.com/glycerine/goconvey v0.0.0-20190315024820-982ee783a72e/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
 github.com/glycerine/goconvey v0.0.0-20190410193231-58a59202ab31/go.mod h1:Ogl1Tioa0aV7gstGFO7KhffUsb9M4ydbEbbxpcEDc24=
+github.com/go-chi/chi/v5 v5.1.0 h1:acVI1TYaD+hhedDJ3r54HyA6sExp3HfXq7QWEEY/xMw=
+github.com/go-chi/chi/v5 v5.1.0/go.mod h1:DslCQbL2OYiznFReuXYUmQ2hGd1aDpCnlMNITLSKoi8=
 github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-kit/kit v0.9.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
 github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
@@ -100,6 +104,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/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=
 github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gopherjs/gopherjs v0.0.0-20190309154008-847fc94819f9/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
@@ -119,6 +125,8 @@ 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=
@@ -185,6 +193,10 @@ github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o
 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=
@@ -229,8 +241,6 @@ golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20200106162015-b016eb3dc98e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200413165638-669c56c373c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-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/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=

main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"flag"
 	"goBlack/cmd"
 	"goBlack/common"
@@ -17,6 +18,9 @@ func main() {
 	if err != nil {
 		log.Fatal(err)
 	}
-	cmd.Start(conf)
+	ctx := context.Background()
+	if err := cmd.Start(ctx, conf); err != nil {
+		log.Fatal(err)
+	}
 
 }

pkg/arr/arr.go

@@ -0,0 +1,120 @@
+package arr
+
+import (
+	"bytes"
+	"encoding/json"
+	"goBlack/common"
+	"log"
+	"net/http"
+	"os"
+	"strings"
+	"sync"
+)
+
+// Type is a type of arr
+type Type string
+
+const (
+	Sonarr  Type = "sonarr"
+	Radarr  Type = "radarr"
+	Lidarr  Type = "lidarr"
+	Readarr Type = "readarr"
+)
+
+var (
+	client *common.RLHTTPClient = common.NewRLHTTPClient(nil, nil)
+	logger *log.Logger          = common.NewLogger("QBit", os.Stdout)
+)
+
+type Arr struct {
+	Name  string `json:"name"`
+	Host  string `json:"host"`
+	Token string `json:"token"`
+	Type  Type   `json:"type"`
+}
+
+func NewArr(name, host, token string, arrType Type) *Arr {
+	return &Arr{
+		Name:  name,
+		Host:  host,
+		Token: token,
+		Type:  arrType,
+	}
+}
+
+func (a *Arr) Request(method, endpoint string, payload interface{}) (*http.Response, error) {
+	if a.Token == "" || a.Host == "" {
+		return nil, nil
+	}
+	url, err := common.JoinURL(a.Host, endpoint)
+	if err != nil {
+		return nil, err
+	}
+	var jsonPayload []byte
+
+	if payload != nil {
+		jsonPayload, err = json.Marshal(payload)
+		if err != nil {
+			return nil, err
+		}
+	}
+	req, err := http.NewRequest(method, url, bytes.NewBuffer(jsonPayload))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("X-Api-Key", a.Token)
+	return client.Do(req)
+}
+
+type Storage struct {
+	Arrs map[string]*Arr // name -> arr
+	mu   sync.RWMutex
+}
+
+func inferType(host, name string) Type {
+	switch {
+	case strings.Contains(host, "sonarr") || strings.Contains(name, "sonarr"):
+		return Sonarr
+	case strings.Contains(host, "radarr") || strings.Contains(name, "radarr"):
+		return Radarr
+	case strings.Contains(host, "lidarr") || strings.Contains(name, "lidarr"):
+		return Lidarr
+	case strings.Contains(host, "readarr") || strings.Contains(name, "readarr"):
+		return Readarr
+	default:
+		return ""
+	}
+}
+
+func NewStorage() *Storage {
+	arrs := make(map[string]*Arr)
+	//for name, arrCfg := range cfg {
+	//	arrs[name] = NewArr(name, arrCfg.Host, arrCfg.Token, inferType(arrCfg.Host, name))
+	//}
+	return &Storage{
+		Arrs: arrs,
+	}
+}
+
+func (as *Storage) AddOrUpdate(arr *Arr) {
+	as.mu.Lock()
+	defer as.mu.Unlock()
+	as.Arrs[arr.Host] = arr
+}
+
+func (as *Storage) Get(name string) *Arr {
+	as.mu.RLock()
+	defer as.mu.RUnlock()
+	return as.Arrs[name]
+}
+
+func (as *Storage) GetAll() []*Arr {
+	as.mu.RLock()
+	defer as.mu.RUnlock()
+	arrs := make([]*Arr, 0, len(as.Arrs))
+	for _, arr := range as.Arrs {
+		arrs = append(arrs, arr)
+	}
+	return arrs
+}

pkg/arr/content.go

@@ -0,0 +1,29 @@
+package arr
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+)
+
+type ContentRequest struct {
+	ID    string `json:"id"`
+	Title string `json:"name"`
+	Arr   string `json:"arr"`
+}
+
+func (a *Arr) GetContents() *ContentRequest {
+	resp, err := a.Request(http.MethodGet, "api/v3/series", nil)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+	var data *ContentRequest
+	if err = json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return nil
+	}
+	fmt.Printf("Data: %v\n", data)
+	//data.Arr = a.Name
+	return data
+}

pkg/arr/history.go

@@ -0,0 +1,41 @@
+package arr
+
+import (
+	"encoding/json"
+	"net/http"
+	gourl "net/url"
+)
+
+type HistorySchema 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"`
+}
+
+func (a *Arr) GetHistory(downloadId, eventType string) *HistorySchema {
+	query := gourl.Values{}
+	if downloadId != "" {
+		query.Add("downloadId", downloadId)
+	}
+	query.Add("eventType", eventType)
+	query.Add("pageSize", "100")
+	url := "history" + "?" + query.Encode()
+	resp, err := a.Request(http.MethodGet, url, nil)
+	if err != nil {
+		return nil
+	}
+	defer resp.Body.Close()
+	var data *HistorySchema
+
+	if err = json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil
+	}
+	return data
+
+}

pkg/arr/import.go

@@ -0,0 +1,209 @@
+package arr
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	gourl "net/url"
+	"strconv"
+	"time"
+)
+
+type ImportResponseSchema struct {
+	Path         string `json:"path"`
+	RelativePath string `json:"relativePath"`
+	FolderName   string `json:"folderName"`
+	Name         string `json:"name"`
+	Size         int    `json:"size"`
+	Series       struct {
+		Title     string `json:"title"`
+		SortTitle string `json:"sortTitle"`
+		Status    string `json:"status"`
+		Ended     bool   `json:"ended"`
+		Overview  string `json:"overview"`
+		Network   string `json:"network"`
+		AirTime   string `json:"airTime"`
+		Images    []struct {
+			CoverType string `json:"coverType"`
+			RemoteUrl string `json:"remoteUrl"`
+		} `json:"images"`
+		OriginalLanguage struct {
+			Id   int    `json:"id"`
+			Name string `json:"name"`
+		} `json:"originalLanguage"`
+		Seasons []struct {
+			SeasonNumber int  `json:"seasonNumber"`
+			Monitored    bool `json:"monitored"`
+		} `json:"seasons"`
+		Year              int           `json:"year"`
+		Path              string        `json:"path"`
+		QualityProfileId  int           `json:"qualityProfileId"`
+		SeasonFolder      bool          `json:"seasonFolder"`
+		Monitored         bool          `json:"monitored"`
+		MonitorNewItems   string        `json:"monitorNewItems"`
+		UseSceneNumbering bool          `json:"useSceneNumbering"`
+		Runtime           int           `json:"runtime"`
+		TvdbId            int           `json:"tvdbId"`
+		TvRageId          int           `json:"tvRageId"`
+		TvMazeId          int           `json:"tvMazeId"`
+		TmdbId            int           `json:"tmdbId"`
+		FirstAired        time.Time     `json:"firstAired"`
+		LastAired         time.Time     `json:"lastAired"`
+		SeriesType        string        `json:"seriesType"`
+		CleanTitle        string        `json:"cleanTitle"`
+		ImdbId            string        `json:"imdbId"`
+		TitleSlug         string        `json:"titleSlug"`
+		Certification     string        `json:"certification"`
+		Genres            []string      `json:"genres"`
+		Tags              []interface{} `json:"tags"`
+		Added             time.Time     `json:"added"`
+		Ratings           struct {
+			Votes int     `json:"votes"`
+			Value float64 `json:"value"`
+		} `json:"ratings"`
+		LanguageProfileId int `json:"languageProfileId"`
+		Id                int `json:"id"`
+	} `json:"series"`
+	SeasonNumber int `json:"seasonNumber"`
+	Episodes     []struct {
+		SeriesId                 int       `json:"seriesId"`
+		TvdbId                   int       `json:"tvdbId"`
+		EpisodeFileId            int       `json:"episodeFileId"`
+		SeasonNumber             int       `json:"seasonNumber"`
+		EpisodeNumber            int       `json:"episodeNumber"`
+		Title                    string    `json:"title"`
+		AirDate                  string    `json:"airDate"`
+		AirDateUtc               time.Time `json:"airDateUtc"`
+		Runtime                  int       `json:"runtime"`
+		Overview                 string    `json:"overview"`
+		HasFile                  bool      `json:"hasFile"`
+		Monitored                bool      `json:"monitored"`
+		AbsoluteEpisodeNumber    int       `json:"absoluteEpisodeNumber"`
+		UnverifiedSceneNumbering bool      `json:"unverifiedSceneNumbering"`
+		Id                       int       `json:"id"`
+		FinaleType               string    `json:"finaleType,omitempty"`
+	} `json:"episodes"`
+	ReleaseGroup string `json:"releaseGroup"`
+	Quality      struct {
+		Quality struct {
+			Id         int    `json:"id"`
+			Name       string `json:"name"`
+			Source     string `json:"source"`
+			Resolution int    `json:"resolution"`
+		} `json:"quality"`
+		Revision struct {
+			Version  int  `json:"version"`
+			Real     int  `json:"real"`
+			IsRepack bool `json:"isRepack"`
+		} `json:"revision"`
+	} `json:"quality"`
+	Languages []struct {
+		Id   int    `json:"id"`
+		Name string `json:"name"`
+	} `json:"languages"`
+	QualityWeight     int           `json:"qualityWeight"`
+	CustomFormats     []interface{} `json:"customFormats"`
+	CustomFormatScore int           `json:"customFormatScore"`
+	IndexerFlags      int           `json:"indexerFlags"`
+	ReleaseType       string        `json:"releaseType"`
+	Rejections        []struct {
+		Reason string `json:"reason"`
+		Type   string `json:"type"`
+	} `json:"rejections"`
+	Id int `json:"id"`
+}
+
+type ManualImportRequestFile struct {
+	Path         string `json:"path"`
+	SeriesId     int    `json:"seriesId"`
+	SeasonNumber int    `json:"seasonNumber"`
+	EpisodeIds   []int  `json:"episodeIds"`
+	Quality      struct {
+		Quality struct {
+			Id         int    `json:"id"`
+			Name       string `json:"name"`
+			Source     string `json:"source"`
+			Resolution int    `json:"resolution"`
+		} `json:"quality"`
+		Revision struct {
+			Version  int  `json:"version"`
+			Real     int  `json:"real"`
+			IsRepack bool `json:"isRepack"`
+		} `json:"revision"`
+	} `json:"quality"`
+	Languages []struct {
+		Id   int    `json:"id"`
+		Name string `json:"name"`
+	} `json:"languages"`
+	ReleaseGroup      string        `json:"releaseGroup"`
+	CustomFormats     []interface{} `json:"customFormats"`
+	CustomFormatScore int           `json:"customFormatScore"`
+	IndexerFlags      int           `json:"indexerFlags"`
+	ReleaseType       string        `json:"releaseType"`
+	Rejections        []struct {
+		Reason string `json:"reason"`
+		Type   string `json:"type"`
+	} `json:"rejections"`
+}
+
+type ManualImportRequestSchema struct {
+	Name       string                    `json:"name"`
+	Files      []ManualImportRequestFile `json:"files"`
+	ImportMode string                    `json:"importMode"`
+}
+
+func (a *Arr) Import(path string, seriesId int, seasons []int) (io.ReadCloser, error) {
+	query := gourl.Values{}
+	query.Add("folder", path)
+	if seriesId != 0 {
+		query.Add("seriesId", strconv.Itoa(seriesId))
+	}
+	url := "api/v3/manualimport" + "?" + query.Encode()
+	resp, err := a.Request(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to import, invalid file: %w", err)
+	}
+	defer resp.Body.Close()
+	var data []ImportResponseSchema
+	if err = json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil, fmt.Errorf("failed to decode response: %w", err)
+	}
+
+	var files []ManualImportRequestFile
+	for _, d := range data {
+		episodesIds := []int{}
+		for _, e := range d.Episodes {
+			episodesIds = append(episodesIds, e.Id)
+		}
+		file := ManualImportRequestFile{
+			Path:              d.Path,
+			SeriesId:          d.Series.Id,
+			SeasonNumber:      d.SeasonNumber,
+			EpisodeIds:        episodesIds,
+			Quality:           d.Quality,
+			Languages:         d.Languages,
+			ReleaseGroup:      d.ReleaseGroup,
+			CustomFormats:     d.CustomFormats,
+			CustomFormatScore: d.CustomFormatScore,
+			IndexerFlags:      d.IndexerFlags,
+			ReleaseType:       d.ReleaseType,
+			Rejections:        d.Rejections,
+		}
+		files = append(files, file)
+	}
+	request := ManualImportRequestSchema{
+		Name:       "ManualImport",
+		Files:      files,
+		ImportMode: "copy",
+	}
+
+	url = "api/v3/command"
+	resp, err = a.Request(http.MethodPost, url, request)
+	if err != nil {
+		return nil, fmt.Errorf("failed to import: %w", err)
+	}
+	defer resp.Body.Close()
+	return resp.Body, nil
+
+}

pkg/arr/refresh.go

@@ -0,0 +1,54 @@
+package arr
+
+import (
+	"cmp"
+	"fmt"
+	"goBlack/common"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+func (a *Arr) Refresh() error {
+	payload := map[string]string{"name": "RefreshMonitoredDownloads"}
+
+	resp, err := a.Request(http.MethodPost, "api/v3/command", payload)
+	if err == nil && resp != nil {
+		statusOk := strconv.Itoa(resp.StatusCode)[0] == '2'
+		if statusOk {
+			return nil
+		}
+	}
+	return fmt.Errorf("failed to refresh monitored downloads for %s", cmp.Or(a.Name, a.Host))
+}
+
+func (a *Arr) MarkAsFailed(infoHash string) error {
+	downloadId := strings.ToUpper(infoHash)
+	history := a.GetHistory(downloadId, "grabbed")
+	if history == nil {
+		return nil
+	}
+	torrentId := 0
+	for _, record := range history.Records {
+		if strings.EqualFold(record.DownloadID, downloadId) {
+			torrentId = record.ID
+			break
+		}
+	}
+	if torrentId != 0 {
+		url, err := common.JoinURL(a.Host, "history/failed/", strconv.Itoa(torrentId))
+		if err != nil {
+			return err
+		}
+		req, err := http.NewRequest(http.MethodPost, url, nil)
+		if err != nil {
+			return err
+		}
+		client := &http.Client{}
+		_, err = client.Do(req)
+		if err == nil {
+			return fmt.Errorf("failed to mark %s as failed: %v", cmp.Or(a.Name, a.Host), err)
+		}
+	}
+	return nil
+}

pkg/arr/tmdb.go

@@ -0,0 +1,31 @@
+package arr
+
+import (
+	"encoding/json"
+	"net/http"
+	url2 "net/url"
+)
+
+type TMDBResponse struct {
+	Page    int `json:"page"`
+	Results []struct {
+		ID         int    `json:"id"`
+		Name       string `json:"name"`
+		MediaType  string `json:"media_type"`
+		PosterPath string `json:"poster_path"`
+	} `json:"results"`
+}
+
+func SearchTMDB(term string) (*TMDBResponse, error) {
+	resp, err := http.Get("https://api.themoviedb.org/3/search/multi?api_key=key&query=" + url2.QueryEscape(term))
+	if err != nil {
+		return nil, err
+	}
+
+	var data *TMDBResponse
+	if err = json.NewDecoder(resp.Body).Decode(&data); err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}

pkg/debrid/debrid.go

@@ -0,0 +1,184 @@
+package debrid
+
+import (
+	"fmt"
+	"github.com/anacrolix/torrent/metainfo"
+	"goBlack/common"
+	"goBlack/pkg/arr"
+	"log"
+	"path/filepath"
+)
+
+type BaseDebrid struct {
+	Name             string
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *common.RLHTTPClient
+	cache            *common.Cache
+	MountPath        string
+	logger           *log.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() *log.Logger
+}
+
+func NewDebrid(debs []common.DebridConfig, cache *common.Cache) *DebridService {
+	debrids := make([]Service, 0)
+	for _, dc := range debs {
+		d := createDebrid(dc, cache)
+		d.GetLogger().Println("Debrid Service started")
+		debrids = append(debrids, d)
+	}
+	d := &DebridService{debrids: debrids, lastUsed: 0}
+	return d
+}
+
+func createDebrid(dc common.DebridConfig, cache *common.Cache) Service {
+	switch dc.Name {
+	case "realdebrid":
+		return NewRealDebrid(dc, cache)
+	case "torbox":
+		return NewTorbox(dc, cache)
+	case "debridlink":
+		return NewDebridLink(dc, cache)
+	default:
+		return NewRealDebrid(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)
+
+	//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{
+		InfoHash: magnet.InfoHash,
+		Magnet:   magnet,
+		Name:     magnet.Name,
+		Arr:      a,
+		Size:     magnet.Size,
+	}
+
+	errs := make([]error, 0)
+
+	for index, db := range d.debrids {
+		log.Println("Processing debrid: ", db.GetName())
+		logger := db.GetLogger()
+		logger.Printf("Torrent Hash: %s", debridTorrent.InfoHash)
+		if db.GetCheckCached() {
+			hash, exists := db.IsAvailable([]string{debridTorrent.InfoHash})[debridTorrent.InfoHash]
+			if !exists || !hash {
+				logger.Printf("Torrent: %s is not cached", debridTorrent.Name)
+				continue
+			} else {
+				logger.Printf("Torrent: %s is cached(or downloading)", debridTorrent.Name)
+			}
+		}
+
+		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.Printf("Torrent: %s submitted to %s", dbt.Name, db.GetName())
+		d.lastUsed = index
+		return db.CheckStatus(dbt, isSymlink)
+	}
+	err := fmt.Errorf("failed to process torrent")
+	for _, e := range errs {
+		err = fmt.Errorf("%w\n%w", err, e)
+	}
+	return nil, err
+}

pkg/debrid/debrid_link.go

@@ -0,0 +1,271 @@
+package debrid
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"goBlack/common"
+	"goBlack/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() *log.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 += 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/seedbox/cached/%s", r.Host, hashStr)
+		req, _ := http.NewRequest(http.MethodGet, url, nil)
+		resp, err := r.client.MakeRequest(req)
+		if err != nil {
+			log.Println("Error checking availability:", err)
+			return result
+		}
+		var data structs.DebridLinkAvailableResponse
+		err = json.Unmarshal(resp, &data)
+		if err != nil {
+			log.Println("Error marshalling availability:", 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,
+		}
+	}
+	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\n", 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,
+			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.Printf("Torrent: %s downloaded\n", 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.Printf("Torrent: %s deleted\n", torrent.Name)
+	} else {
+		r.logger.Printf("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, 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/realdebrid.go

@@ -0,0 +1,295 @@
+package debrid
+
+import (
+	"encoding/json"
+	"fmt"
+	"goBlack/common"
+	"goBlack/pkg/debrid/structs"
+	"log"
+	"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() *log.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.VIDEOMATCH, name) &&
+			!common.RegexMatch(common.SUBMATCH, name) &&
+			!common.RegexMatch(common.MUSICMATCH, name)) || common.RegexMatch(common.SAMPLEMATCH, 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 {
+			log.Println("Error checking availability:", err)
+			return result
+		}
+		var data structs.RealDebridAvailabilityResponse
+		err = json.Unmarshal(resp, &data)
+		if err != nil {
+			log.Println("Error marshalling availability:", 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)
+	log.Printf("Torrent: %s added with id: %s\n", 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 {
+			log.Println("ERROR Checking file: ", err)
+			return torrent, err
+		}
+		var data structs.RealDebridTorrentInfo
+		err = json.Unmarshal(resp, &data)
+		status := data.Status
+		fmt.Println("RD STATUS: ", 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
+		downloading_status := []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
+			log.Printf("Torrent: %s downloaded to RD\n", torrent.Name)
+			if !isSymlink {
+				err = r.GetDownloadLinks(torrent)
+				if err != nil {
+					return torrent, err
+				}
+			}
+			break
+		} else if slices.Contains(downloading_status, 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.Printf("Torrent: %s deleted\n", torrent.Name)
+	} else {
+		r.logger.Printf("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, 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/service.go

@@ -0,0 +1,13 @@
+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]
+}

pkg/debrid/structs/debrid_link.go

@@ -0,0 +1,45 @@
+package structs
+
+type DebridLinkAPIResponse[T any] struct {
+	Success bool `json:"success"`
+	Value   *T   `json:"value"` // Use pointer to allow nil
+}
+
+type DebridLinkAvailableResponse DebridLinkAPIResponse[map[string]map[string]struct {
+	Name       string `json:"name"`
+	HashString string `json:"hashString"`
+	Files      []struct {
+		Name string `json:"name"`
+		Size int    `json:"size"`
+	} `json:"files"`
+}]
+
+type debridLinkTorrentInfo struct {
+	ID             string  `json:"id"`
+	Name           string  `json:"name"`
+	HashString     string  `json:"hashString"`
+	UploadRatio    float64 `json:"uploadRatio"`
+	ServerID       string  `json:"serverId"`
+	Wait           bool    `json:"wait"`
+	PeersConnected int     `json:"peersConnected"`
+	Status         int     `json:"status"`
+	TotalSize      int64   `json:"totalSize"`
+	Files          []struct {
+		ID              string `json:"id"`
+		Name            string `json:"name"`
+		DownloadURL     string `json:"downloadUrl"`
+		Size            int64  `json:"size"`
+		DownloadPercent int    `json:"downloadPercent"`
+	} `json:"files"`
+	Trackers []struct {
+		Announce string `json:"announce"`
+	} `json:"trackers"`
+	Created         int64   `json:"created"`
+	DownloadPercent float64 `json:"downloadPercent"`
+	DownloadSpeed   int     `json:"downloadSpeed"`
+	UploadSpeed     int     `json:"uploadSpeed"`
+}
+
+type DebridLinkTorrentInfo DebridLinkAPIResponse[[]debridLinkTorrentInfo]
+
+type DebridLinkSubmitTorrentInfo DebridLinkAPIResponse[debridLinkTorrentInfo]

pkg/debrid/structs/realdebrid.go

@@ -0,0 +1,107 @@
+package structs
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+type RealDebridAvailabilityResponse map[string]Hoster
+
+func (r *RealDebridAvailabilityResponse) UnmarshalJSON(data []byte) error {
+	// First, try to unmarshal as an object
+	var objectData map[string]Hoster
+	err := json.Unmarshal(data, &objectData)
+	if err == nil {
+		*r = objectData
+		return nil
+	}
+
+	// If that fails, try to unmarshal as an array
+	var arrayData []map[string]Hoster
+	err = json.Unmarshal(data, &arrayData)
+	if err != nil {
+		return fmt.Errorf("failed to unmarshal as both object and array: %v", err)
+	}
+
+	// If it's an array, use the first element
+	if len(arrayData) > 0 {
+		*r = arrayData[0]
+		return nil
+	}
+
+	// If it's an empty array, initialize as an empty map
+	*r = make(map[string]Hoster)
+	return nil
+}
+
+type Hoster struct {
+	Rd []map[string]FileVariant `json:"rd"`
+}
+
+func (h *Hoster) UnmarshalJSON(data []byte) error {
+	// Attempt to unmarshal into the expected structure (an object with an "rd" key)
+	type Alias Hoster
+	var obj Alias
+	if err := json.Unmarshal(data, &obj); err == nil {
+		*h = Hoster(obj)
+		return nil
+	}
+
+	// If unmarshalling into an object fails, check if it's an empty array
+	var arr []interface{}
+	if err := json.Unmarshal(data, &arr); err == nil && len(arr) == 0 {
+		// It's an empty array; initialize with no entries
+		*h = Hoster{Rd: nil}
+		return nil
+	}
+
+	// If both attempts fail, return an error
+	return fmt.Errorf("hoster: cannot unmarshal JSON data: %s", string(data))
+}
+
+type FileVariant struct {
+	Filename string `json:"filename"`
+	Filesize int    `json:"filesize"`
+}
+
+type RealDebridAddMagnetSchema struct {
+	Id  string `json:"id"`
+	Uri string `json:"uri"`
+}
+
+type RealDebridTorrentInfo struct {
+	ID               string  `json:"id"`
+	Filename         string  `json:"filename"`
+	OriginalFilename string  `json:"original_filename"`
+	Hash             string  `json:"hash"`
+	Bytes            int64   `json:"bytes"`
+	OriginalBytes    int64   `json:"original_bytes"`
+	Host             string  `json:"host"`
+	Split            int     `json:"split"`
+	Progress         float64 `json:"progress"`
+	Status           string  `json:"status"`
+	Added            string  `json:"added"`
+	Files            []struct {
+		ID       int    `json:"id"`
+		Path     string `json:"path"`
+		Bytes    int64  `json:"bytes"`
+		Selected int    `json:"selected"`
+	} `json:"files"`
+	Links   []string `json:"links"`
+	Ended   string   `json:"ended,omitempty"`
+	Speed   int      `json:"speed,omitempty"`
+	Seeders int      `json:"seeders,omitempty"`
+}
+
+type RealDebridUnrestrictResponse struct {
+	Id         string `json:"id"`
+	Filename   string `json:"filename"`
+	MimeType   string `json:"mimeType"`
+	Filesize   int    `json:"filesize"`
+	Link       string `json:"link"`
+	Host       string `json:"host"`
+	Chunks     int    `json:"chunks"`
+	Crc        int    `json:"crc"`
+	Download   string `json:"download"`
+	Streamable int    `json:"streamable"`
+}

pkg/debrid/structs/torbox.go

@@ -0,0 +1,75 @@
+package structs
+
+import "time"
+
+type TorboxAPIResponse[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 {
+	Name string `json:"name"`
+	Size int    `json:"size"`
+	Hash string `json:"hash"`
+}]
+
+type TorBoxAddMagnetResponse TorboxAPIResponse[struct {
+	Id   int    `json:"torrent_id"`
+	Hash string `json:"hash"`
+}]
+
+type torboxInfo struct {
+	Id              int         `json:"id"`
+	AuthId          string      `json:"auth_id"`
+	Server          int         `json:"server"`
+	Hash            string      `json:"hash"`
+	Name            string      `json:"name"`
+	Magnet          interface{} `json:"magnet"`
+	Size            int64       `json:"size"`
+	Active          bool        `json:"active"`
+	CreatedAt       time.Time   `json:"created_at"`
+	UpdatedAt       time.Time   `json:"updated_at"`
+	DownloadState   string      `json:"download_state"`
+	Seeds           int         `json:"seeds"`
+	Peers           int         `json:"peers"`
+	Ratio           float64     `json:"ratio"`
+	Progress        float64     `json:"progress"`
+	DownloadSpeed   int         `json:"download_speed"`
+	UploadSpeed     int         `json:"upload_speed"`
+	Eta             int         `json:"eta"`
+	TorrentFile     bool        `json:"torrent_file"`
+	ExpiresAt       interface{} `json:"expires_at"`
+	DownloadPresent bool        `json:"download_present"`
+	Files           []struct {
+		Id           int         `json:"id"`
+		Md5          interface{} `json:"md5"`
+		Hash         string      `json:"hash"`
+		Name         string      `json:"name"`
+		Size         int64       `json:"size"`
+		Zipped       bool        `json:"zipped"`
+		S3Path       string      `json:"s3_path"`
+		Infected     bool        `json:"infected"`
+		Mimetype     string      `json:"mimetype"`
+		ShortName    string      `json:"short_name"`
+		AbsolutePath string      `json:"absolute_path"`
+	} `json:"files"`
+	DownloadPath     string      `json:"download_path"`
+	InactiveCheck    int         `json:"inactive_check"`
+	Availability     int         `json:"availability"`
+	DownloadFinished bool        `json:"download_finished"`
+	Tracker          interface{} `json:"tracker"`
+	TotalUploaded    int         `json:"total_uploaded"`
+	TotalDownloaded  int         `json:"total_downloaded"`
+	Cached           bool        `json:"cached"`
+	Owner            string      `json:"owner"`
+	SeedTorrent      bool        `json:"seed_torrent"`
+	AllowZipped      bool        `json:"allow_zipped"`
+	LongTermSeeding  bool        `json:"long_term_seeding"`
+	TrackerMessage   interface{} `json:"tracker_message"`
+}
+
+type TorboxInfoResponse TorboxAPIResponse[torboxInfo]
+
+type TorBoxDownloadLinksResponse TorboxAPIResponse[string]

pkg/debrid/torbox.go

@@ -0,0 +1,303 @@
+package debrid
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"goBlack/common"
+	"goBlack/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() *log.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 += 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/api/torrents/checkcached?hash=%s", r.Host, hashStr)
+		req, _ := http.NewRequest(http.MethodGet, url, nil)
+		resp, err := r.client.MakeRequest(req)
+		if err != nil {
+			log.Println("Error checking availability:", err)
+			return result
+		}
+		var res structs.TorBoxAvailableResponse
+		err = json.Unmarshal(resp, &res)
+		if err != nil {
+			log.Println("Error marshalling availability:", 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\n", torrent.Name, torrentId)
+	torrent.Id = torrentId
+
+	return torrent, nil
+}
+
+func getStatus(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 = getStatus(data.DownloadState, data.DownloadFinished)
+	torrent.Speed = data.DownloadSpeed
+	torrent.Seeders = data.Seeds
+	torrent.Filename = name
+	torrent.OriginalFilename = name
+	files := make([]TorrentFile, 0)
+	if len(data.Files) == 0 {
+		return torrent, fmt.Errorf("no files found for torrent: %s", name)
+	}
+	for _, f := range data.Files {
+		fileName := filepath.Base(f.Name)
+		if (!common.RegexMatch(common.VIDEOMATCH, fileName) &&
+			!common.RegexMatch(common.SUBMATCH, fileName) &&
+			!common.RegexMatch(common.MUSICMATCH, fileName)) || common.RegexMatch(common.SAMPLEMATCH, fileName) {
+			continue
+		}
+		file := TorrentFile{
+			Id:   strconv.Itoa(f.Id),
+			Name: fileName,
+			Size: f.Size,
+			Path: fileName,
+		}
+		files = append(files, file)
+	}
+	if len(files) == 0 {
+		return torrent, fmt.Errorf("no video files found")
+	}
+	cleanPath := path.Clean(data.Files[0].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.Printf("Torrent: %s downloaded\n", 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.Printf("Torrent: %s deleted\n", torrent.Name)
+	} else {
+		r.logger.Printf("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, 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/torrent.go

@@ -0,0 +1,116 @@
+package debrid
+
+import (
+	"goBlack/common"
+	"goBlack/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 {
+	possiblePaths := []string{
+		t.OriginalFilename,
+		t.Filename,
+		common.RemoveExtension(t.OriginalFilename),
+	}
+
+	for _, path := range possiblePaths {
+		if path != "" && common.FileReady(filepath.Join(rClonePath, path)) {
+			return path
+		}
+	}
+	return ""
+}
+
+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/downloaders/fasthttp.go

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,55 @@
+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%%)\n",
+				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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,346 @@
+package proxy
+
+import (
+	"bytes"
+	"cmp"
+	"context"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"github.com/elazarl/goproxy"
+	"github.com/elazarl/goproxy/ext/auth"
+	"github.com/valyala/fastjson"
+	"goBlack/common"
+	"goBlack/pkg/debrid"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+type RSS struct {
+	XMLName xml.Name `xml:"rss"`
+	Text    string   `xml:",chardata"`
+	Version string   `xml:"version,attr"`
+	Atom    string   `xml:"atom,attr"`
+	Torznab string   `xml:"torznab,attr"`
+	Channel struct {
+		Text string `xml:",chardata"`
+		Link struct {
+			Text string `xml:",chardata"`
+			Rel  string `xml:"rel,attr"`
+			Type string `xml:"type,attr"`
+		} `xml:"link"`
+		Title string `xml:"title"`
+		Items []Item `xml:"item"`
+	} `xml:"channel"`
+}
+
+type Item struct {
+	Text            string `xml:",chardata"`
+	Title           string `xml:"title"`
+	Description     string `xml:"description"`
+	GUID            string `xml:"guid"`
+	ProwlarrIndexer struct {
+		Text string `xml:",chardata"`
+		ID   string `xml:"id,attr"`
+		Type string `xml:"type,attr"`
+	} `xml:"prowlarrindexer"`
+	Comments  string   `xml:"comments"`
+	PubDate   string   `xml:"pubDate"`
+	Size      string   `xml:"size"`
+	Link      string   `xml:"link"`
+	Category  []string `xml:"category"`
+	Enclosure struct {
+		Text   string `xml:",chardata"`
+		URL    string `xml:"url,attr"`
+		Length string `xml:"length,attr"`
+		Type   string `xml:"type,attr"`
+	} `xml:"enclosure"`
+	TorznabAttrs []struct {
+		Text  string `xml:",chardata"`
+		Name  string `xml:"name,attr"`
+		Value string `xml:"value,attr"`
+	} `xml:"attr"`
+}
+
+type Proxy struct {
+	port       string
+	enabled    bool
+	debug      bool
+	username   string
+	password   string
+	cachedOnly bool
+	debrid     debrid.Service
+	cache      *common.Cache
+	logger     *log.Logger
+}
+
+func NewProxy(config common.Config, deb *debrid.DebridService, cache *common.Cache) *Proxy {
+	cfg := config.Proxy
+	port := cmp.Or(os.Getenv("PORT"), cfg.Port, "8181")
+	return &Proxy{
+		port:       port,
+		enabled:    cfg.Enabled,
+		debug:      cfg.Debug,
+		username:   cfg.Username,
+		password:   cfg.Password,
+		cachedOnly: *cfg.CachedOnly,
+		debrid:     deb.Get(),
+		cache:      cache,
+		logger:     common.NewLogger("Proxy", os.Stdout),
+	}
+}
+
+func (p *Proxy) ProcessJSONResponse(resp *http.Response) *http.Response {
+	if resp == nil || resp.Body == nil {
+		return resp
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return resp
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return nil
+	}
+
+	var par fastjson.Parser
+	v, err := par.ParseBytes(body)
+	if err != nil {
+		// If it's not JSON, return the original response
+		resp.Body = io.NopCloser(bytes.NewReader(body))
+		return resp
+	}
+
+	// Modify the JSON
+
+	// Serialize the modified JSON back to bytes
+	modifiedBody := v.MarshalTo(nil)
+
+	// Set the modified body back to the response
+	resp.Body = io.NopCloser(bytes.NewReader(modifiedBody))
+	resp.ContentLength = int64(len(modifiedBody))
+	resp.Header.Set("Content-Length", string(rune(len(modifiedBody))))
+
+	return resp
+
+}
+
+func (p *Proxy) ProcessResponse(resp *http.Response) *http.Response {
+	if resp == nil || resp.Body == nil {
+		return resp
+	}
+	contentType := resp.Header.Get("Content-Type")
+	switch contentType {
+	case "application/json":
+		return resp // p.ProcessJSONResponse(resp)
+	case "application/xml":
+		return p.ProcessXMLResponse(resp)
+	case "application/rss+xml":
+		return p.ProcessXMLResponse(resp)
+	default:
+		return resp
+	}
+}
+
+func getItemsHash(items []Item) map[string]string {
+
+	var wg sync.WaitGroup
+	idHashMap := sync.Map{} // Use sync.Map for concurrent access
+
+	for _, item := range items {
+		wg.Add(1)
+		go func(item Item) {
+			defer wg.Done()
+			hash := strings.ToLower(item.getHash())
+			if hash != "" {
+				idHashMap.Store(item.GUID, hash) // Store directly into sync.Map
+			}
+		}(item)
+	}
+	wg.Wait()
+
+	// Convert sync.Map to regular map
+	finalMap := make(map[string]string)
+	idHashMap.Range(func(key, value interface{}) bool {
+		finalMap[key.(string)] = value.(string)
+		return true
+	})
+
+	return finalMap
+}
+
+func (item Item) getHash() string {
+	infohash := ""
+
+	for _, attr := range item.TorznabAttrs {
+		if attr.Name == "infohash" {
+			return attr.Value
+		}
+	}
+
+	if strings.Contains(item.GUID, "magnet:?") {
+		magnet, err := common.GetMagnetInfo(item.GUID)
+		if err == nil && magnet != nil && magnet.InfoHash != "" {
+			return magnet.InfoHash
+		}
+	}
+
+	magnetLink := item.Link
+
+	if magnetLink == "" {
+		// We can't check the availability of the torrent without a magnet link or infohash
+		return ""
+	}
+
+	if strings.Contains(magnetLink, "magnet:?") {
+		magnet, err := common.GetMagnetInfo(magnetLink)
+		if err == nil && magnet != nil && magnet.InfoHash != "" {
+			return magnet.InfoHash
+		}
+	}
+
+	//Check Description for infohash
+	hash := common.ExtractInfoHash(item.Description)
+	if hash == "" {
+		// Check Title for infohash
+		hash = common.ExtractInfoHash(item.Comments)
+	}
+	infohash = hash
+	if infohash == "" {
+		if strings.Contains(magnetLink, "http") {
+			h, _ := common.GetInfohashFromURL(magnetLink)
+			if h != "" {
+				infohash = h
+			}
+		}
+	}
+	return infohash
+
+}
+
+func (p *Proxy) ProcessXMLResponse(resp *http.Response) *http.Response {
+	if resp == nil || resp.Body == nil {
+		return resp
+	}
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		p.logger.Println("Error reading response body:", err)
+		resp.Body = io.NopCloser(bytes.NewReader(body))
+		return resp
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return nil
+	}
+
+	var rss RSS
+	err = xml.Unmarshal(body, &rss)
+	if err != nil {
+		p.logger.Printf("Error unmarshalling XML: %v", err)
+		resp.Body = io.NopCloser(bytes.NewReader(body))
+		return resp
+	}
+	indexer := ""
+	if len(rss.Channel.Items) > 0 {
+		indexer = rss.Channel.Items[0].ProwlarrIndexer.Text
+	} else {
+		resp.Body = io.NopCloser(bytes.NewReader(body))
+		return resp
+	}
+
+	// Step 4: Extract infohash or magnet URI, manipulate data
+	IdsHashMap := getItemsHash(rss.Channel.Items)
+	hashes := make([]string, 0)
+	for _, hash := range IdsHashMap {
+		if hash != "" {
+			hashes = append(hashes, hash)
+		}
+	}
+	availableHashesMap := p.debrid.IsAvailable(hashes)
+	newItems := make([]Item, 0, len(rss.Channel.Items))
+
+	if len(hashes) > 0 {
+		for _, item := range rss.Channel.Items {
+			hash := IdsHashMap[item.GUID]
+			if hash == "" {
+				continue
+			}
+			isCached, exists := availableHashesMap[hash]
+			if !exists || !isCached {
+				continue
+			}
+			newItems = append(newItems, item)
+		}
+	}
+
+	if len(newItems) > 0 {
+		p.logger.Printf("[%s Report]: %d/%d items are cached || Found %d infohash", indexer, len(newItems), len(rss.Channel.Items), len(hashes))
+	} else {
+		// This will prevent the indexer from being disabled by the arr
+		p.logger.Printf("[%s Report]: No Items are cached; Return only first item with [UnCached]", indexer)
+		item := rss.Channel.Items[0]
+		item.Title = fmt.Sprintf("%s [UnCached]", item.Title)
+		newItems = append(newItems, item)
+	}
+
+	rss.Channel.Items = newItems
+	modifiedBody, err := xml.MarshalIndent(rss, "", "  ")
+	if err != nil {
+		p.logger.Printf("Error marshalling XML: %v", err)
+		resp.Body = io.NopCloser(bytes.NewReader(body))
+		return resp
+	}
+	modifiedBody = append([]byte(xml.Header), modifiedBody...)
+
+	// Set the modified body back to the response
+	resp.Body = io.NopCloser(bytes.NewReader(modifiedBody))
+	return resp
+}
+
+func UrlMatches(re *regexp.Regexp) goproxy.ReqConditionFunc {
+	return func(req *http.Request, ctx *goproxy.ProxyCtx) bool {
+		return re.MatchString(req.URL.String())
+	}
+}
+
+func (p *Proxy) Start(ctx context.Context) error {
+	username, password := p.username, p.password
+	proxy := goproxy.NewProxyHttpServer()
+	if username != "" || password != "" {
+		// Set up basic auth for proxy
+		auth.ProxyBasic(proxy, "my_realm", func(user, pwd string) bool {
+			return user == username && password == pwd
+		})
+	}
+
+	proxy.OnRequest(goproxy.ReqHostMatches(regexp.MustCompile("^.443$"))).HandleConnect(goproxy.AlwaysMitm)
+	proxy.OnResponse(
+		UrlMatches(regexp.MustCompile("^.*/api\\?t=(search|tvsearch|movie)(&.*)?$")),
+		goproxy.StatusCodeIs(http.StatusOK, http.StatusAccepted)).DoFunc(
+		func(resp *http.Response, ctx *goproxy.ProxyCtx) *http.Response {
+			return p.ProcessResponse(resp)
+		})
+
+	proxy.Verbose = p.debug
+	portFmt := fmt.Sprintf(":%s", p.port)
+	srv := &http.Server{
+		Addr:    portFmt,
+		Handler: proxy,
+	}
+	p.logger.Printf("[*] Starting proxy server on %s\n", portFmt)
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			p.logger.Printf("Error starting proxy server: %v\n", err)
+		}
+	}()
+	<-ctx.Done()
+	p.logger.Println("Shutting down gracefully...")
+	return srv.Shutdown(context.Background())
+}

pkg/qbit/main.go

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

pkg/qbit/server/app_handlers.go

@@ -0,0 +1,42 @@
+package server
+
+import (
+	"goBlack/common"
+	"goBlack/pkg/qbit/shared"
+	"net/http"
+	"path/filepath"
+)
+
+func (s *Server) handleVersion(w http.ResponseWriter, r *http.Request) {
+	_, _ = w.Write([]byte("v4.3.2"))
+}
+
+func (s *Server) handleWebAPIVersion(w http.ResponseWriter, r *http.Request) {
+	_, _ = w.Write([]byte("2.7"))
+}
+
+func (s *Server) handlePreferences(w http.ResponseWriter, r *http.Request) {
+	preferences := shared.NewAppPreferences()
+
+	preferences.WebUiUsername = s.qbit.Username
+	preferences.SavePath = s.qbit.DownloadFolder
+	preferences.TempPath = filepath.Join(s.qbit.DownloadFolder, "temp")
+
+	common.JSONResponse(w, preferences, http.StatusOK)
+}
+
+func (s *Server) handleBuildInfo(w http.ResponseWriter, r *http.Request) {
+	res := shared.BuildInfo{
+		Bitness:    64,
+		Boost:      "1.75.0",
+		Libtorrent: "1.2.11.0",
+		Openssl:    "1.1.1i",
+		Qt:         "5.15.2",
+		Zlib:       "1.2.11",
+	}
+	common.JSONResponse(w, res, http.StatusOK)
+}
+
+func (s *Server) shutdown(w http.ResponseWriter, r *http.Request) {
+	w.WriteHeader(http.StatusOK)
+}

pkg/qbit/server/auth_handlers.go

@@ -0,0 +1,7 @@
+package server
+
+import "net/http"
+
+func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) {
+	_, _ = w.Write([]byte("Ok."))
+}

pkg/qbit/server/import.go

@@ -0,0 +1,178 @@
+package server
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/google/uuid"
+	"goBlack/common"
+	"goBlack/pkg/arr"
+	"goBlack/pkg/debrid"
+	"sync"
+	"time"
+)
+
+type ImportRequest struct {
+	ID        string   `json:"id"`
+	Path      string   `json:"path"`
+	URI       string   `json:"uri"`
+	Arr       *arr.Arr `json:"arr"`
+	IsSymlink bool     `json:"isSymlink"`
+	SeriesId  int      `json:"series"`
+	Seasons   []int    `json:"seasons"`
+	Episodes  []string `json:"episodes"`
+
+	Failed      bool      `json:"failed"`
+	FailedAt    time.Time `json:"failedAt"`
+	Reason      string    `json:"reason"`
+	Completed   bool      `json:"completed"`
+	CompletedAt time.Time `json:"completedAt"`
+	Async       bool      `json:"async"`
+}
+
+type ManualImportResponseSchema struct {
+	Priority            string    `json:"priority"`
+	Status              string    `json:"status"`
+	Result              string    `json:"result"`
+	Queued              time.Time `json:"queued"`
+	Trigger             string    `json:"trigger"`
+	SendUpdatesToClient bool      `json:"sendUpdatesToClient"`
+	UpdateScheduledTask bool      `json:"updateScheduledTask"`
+	Id                  int       `json:"id"`
+}
+
+func NewImportRequest(uri string, arr *arr.Arr, isSymlink bool) *ImportRequest {
+	return &ImportRequest{
+		ID:        uuid.NewString(),
+		URI:       uri,
+		Arr:       arr,
+		Failed:    false,
+		Completed: false,
+		Async:     false,
+		IsSymlink: isSymlink,
+	}
+}
+
+func (i *ImportRequest) Fail(reason string) {
+	i.Failed = true
+	i.FailedAt = time.Now()
+	i.Reason = reason
+}
+
+func (i *ImportRequest) Complete() {
+	i.Completed = true
+	i.CompletedAt = time.Now()
+}
+
+func (i *ImportRequest) Process(s *Server) (err error) {
+	// Use this for now.
+	// This sends the torrent to the arr
+	q := s.qbit
+	magnet, err := common.GetMagnetFromUrl(i.URI)
+	torrent := q.CreateTorrentFromMagnet(magnet, i.Arr.Name)
+	debridTorrent, err := debrid.ProcessTorrent(q.Debrid, magnet, i.Arr, i.IsSymlink)
+	if err != nil || debridTorrent == nil {
+		if debridTorrent != nil {
+			go debridTorrent.Delete()
+		}
+		if err == nil {
+			err = fmt.Errorf("failed to process torrent")
+		}
+		return err
+	}
+	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
+	q.Storage.AddOrUpdate(torrent)
+	go q.ProcessFiles(torrent, debridTorrent, i.Arr, i.IsSymlink)
+	return nil
+}
+
+func (i *ImportRequest) BetaProcess(s *Server) (err error) {
+	// THis actually imports the torrent into the arr. Needs more work
+	if i.Arr == nil {
+		return errors.New("invalid arr")
+	}
+	q := s.qbit
+	magnet, err := common.GetMagnetFromUrl(i.URI)
+	if err != nil {
+		return fmt.Errorf("error parsing magnet link: %w", err)
+	}
+	debridTorrent, err := debrid.ProcessTorrent(q.Debrid, magnet, i.Arr, true)
+	if err != nil || debridTorrent == nil {
+		if debridTorrent != nil {
+			go debridTorrent.Delete()
+		}
+		if err == nil {
+			err = fmt.Errorf("failed to process torrent")
+		}
+		return err
+	}
+
+	debridTorrent.Arr = i.Arr
+
+	torrentPath, err := q.ProcessSymlink(debridTorrent)
+	if err != nil {
+		return fmt.Errorf("failed to process symlink: %w", err)
+	}
+	i.Path = torrentPath
+	body, err := i.Arr.Import(torrentPath, i.SeriesId, i.Seasons)
+	if err != nil {
+		return fmt.Errorf("failed to import: %w", err)
+	}
+	defer body.Close()
+
+	var resp ManualImportResponseSchema
+	if err := json.NewDecoder(body).Decode(&resp); err != nil {
+		return fmt.Errorf("failed to decode response: %w", err)
+	}
+	if resp.Status != "success" {
+		return fmt.Errorf("failed to import: %s", resp.Result)
+	}
+	i.Complete()
+
+	return
+}
+
+type ImportStore struct {
+	Imports map[string]*ImportRequest
+	mu      sync.RWMutex
+}
+
+func NewImportStore() *ImportStore {
+	return &ImportStore{
+		Imports: make(map[string]*ImportRequest),
+	}
+}
+
+func (s *ImportStore) AddImport(i *ImportRequest) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Imports[i.ID] = i
+}
+
+func (s *ImportStore) GetImport(id string) *ImportRequest {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.Imports[id]
+}
+
+func (s *ImportStore) GetAllImports() []*ImportRequest {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	var imports []*ImportRequest
+	for _, i := range s.Imports {
+		imports = append(imports, i)
+	}
+	return imports
+}
+
+func (s *ImportStore) DeleteImport(id string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	delete(s.Imports, id)
+}
+
+func (s *ImportStore) UpdateImport(i *ImportRequest) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.Imports[i.ID] = i
+}

pkg/qbit/server/middleware.go

@@ -0,0 +1,84 @@
+package server
+
+import (
+	"context"
+	"encoding/base64"
+	"github.com/go-chi/chi/v5"
+	"goBlack/pkg/arr"
+	"net/http"
+	"strings"
+)
+
+func DecodeAuthHeader(header string) (string, string, error) {
+	encodedTokens := strings.Split(header, " ")
+	if len(encodedTokens) != 2 {
+		return "", "", nil
+	}
+	encodedToken := encodedTokens[1]
+
+	bytes, err := base64.StdEncoding.DecodeString(encodedToken)
+	if err != nil {
+		return "", "", err
+	}
+
+	bearer := string(bytes)
+
+	colonIndex := strings.LastIndex(bearer, ":")
+	host := bearer[:colonIndex]
+	token := bearer[colonIndex+1:]
+
+	return host, token, nil
+}
+
+func (s *Server) CategoryContext(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		category := strings.Trim(r.URL.Query().Get("category"), "")
+		if category == "" {
+			// Get from form
+			_ = r.ParseForm()
+			category = r.Form.Get("category")
+			if category == "" {
+				// Get from multipart form
+				_ = r.ParseMultipartForm(0)
+				category = r.FormValue("category")
+			}
+		}
+		ctx := r.Context()
+		ctx = context.WithValue(r.Context(), "category", category)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func (s *Server) 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,
+		}
+		if err == nil {
+			a.Host = host
+			a.Token = token
+		}
+		s.qbit.Arrs.AddOrUpdate(a)
+		ctx := context.WithValue(r.Context(), "arr", a)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func HashesCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_hashes := chi.URLParam(r, "hashes")
+		var hashes []string
+		if _hashes != "" {
+			hashes = strings.Split(_hashes, "|")
+		}
+		if hashes == nil {
+			// Get hashes from form
+			_ = r.ParseForm()
+			hashes = r.Form["hashes"]
+		}
+		ctx := context.WithValue(r.Context(), "hashes", hashes)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}

pkg/qbit/server/routes.go

@@ -0,0 +1,50 @@
+package server
+
+import (
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+func (s *Server) Routes(r chi.Router) http.Handler {
+	r.Route("/api/v2", func(r chi.Router) {
+		r.Use(s.CategoryContext)
+		r.Post("/auth/login", s.handleLogin)
+
+		r.Group(func(r chi.Router) {
+			r.Use(s.authContext)
+			r.Route("/torrents", func(r chi.Router) {
+				r.Use(HashesCtx)
+				r.Get("/info", s.handleTorrentsInfo)
+				r.Post("/add", s.handleTorrentsAdd)
+				r.Post("/delete", s.handleTorrentsDelete)
+				r.Get("/categories", s.handleCategories)
+				r.Post("/createCategory", s.handleCreateCategory)
+
+				r.Get("/pause", s.handleTorrentsPause)
+				r.Get("/resume", s.handleTorrentsResume)
+				r.Get("/recheck", s.handleTorrentRecheck)
+				r.Get("/properties", s.handleTorrentProperties)
+				r.Get("/files", s.handleTorrentFiles)
+			})
+
+			r.Route("/app", func(r chi.Router) {
+				r.Get("/version", s.handleVersion)
+				r.Get("/webapiVersion", s.handleWebAPIVersion)
+				r.Get("/preferences", s.handlePreferences)
+				r.Get("/buildInfo", s.handleBuildInfo)
+				r.Get("/shutdown", s.shutdown)
+			})
+		})
+
+	})
+	r.Get("/", s.handleHome)
+	r.Route("/internal", func(r chi.Router) {
+		r.Get("/arrs", s.handleGetArrs)
+		r.Get("/content", s.handleContent)
+		r.Get("/seasons/{contentId}", s.handleSeasons)
+		r.Get("/episodes/{contentId}", s.handleEpisodes)
+		r.Post("/add", s.handleAddContent)
+		r.Get("/search", s.handleSearch)
+	})
+	return r
+}

pkg/qbit/server/server.go

@@ -0,0 +1,66 @@
+package server
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"goBlack/common"
+	"goBlack/pkg/debrid"
+	"goBlack/pkg/qbit/shared"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+type Server struct {
+	qbit   *shared.QBit
+	logger *log.Logger
+	debug  bool
+}
+
+func NewServer(config *common.Config, deb *debrid.DebridService, cache *common.Cache) *Server {
+	logger := common.NewLogger("QBit", os.Stdout)
+	q := shared.NewQBit(config, deb, cache, logger)
+	return &Server{
+		qbit:   q,
+		logger: logger,
+		debug:  config.QBitTorrent.Debug,
+	}
+}
+
+func (s *Server) Start(ctx context.Context) error {
+	r := chi.NewRouter()
+	if s.debug {
+		r.Use(middleware.Logger)
+	}
+	r.Use(middleware.Recoverer)
+	r.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("static"))))
+	s.Routes(r)
+
+	go s.qbit.StartWorker(context.Background())
+
+	s.logger.Printf("Starting QBit server on :%s", s.qbit.Port)
+	port := fmt.Sprintf(":%s", s.qbit.Port)
+	srv := &http.Server{
+		Addr:    port,
+		Handler: r,
+	}
+
+	ctx, stop := signal.NotifyContext(ctx, os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	go func() {
+		if err := srv.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			fmt.Printf("Error starting server: %v\n", err)
+			stop()
+		}
+	}()
+
+	<-ctx.Done()
+	fmt.Println("Shutting down gracefully...")
+	return srv.Shutdown(context.Background())
+}

pkg/qbit/server/static/index.html

@@ -0,0 +1,334 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Debrid Manager</title>
+    <!-- Bootstrap CSS -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/css/bootstrap.min.css" rel="stylesheet">
+    <!-- Bootstrap Icons -->
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap-icons@1.7.2/font/bootstrap-icons.css" rel="stylesheet">
+    <link href="https://cdn.jsdelivr.net/npm/select2@4.1.0-rc.0/dist/css/select2.min.css" rel="stylesheet"/>
+    <!-- Select2 Bootstrap 5 Theme CSS -->
+    <link rel="stylesheet"
+          href="https://cdn.jsdelivr.net/npm/select2-bootstrap-5-theme@1.3.0/dist/select2-bootstrap-5-theme.min.css"/>
+    <style>
+        .select2-container--bootstrap-5 .select2-results__option {
+            padding: 0.5rem;
+        }
+
+        .select2-result img {
+            border-radius: 4px;
+        }
+
+        .select2-container--bootstrap-5 .select2-results__option--highlighted {
+            background-color: #f8f9fa !important;
+            color: #000 !important;
+        }
+
+        .select2-container--bootstrap-5 .select2-results__option--selected {
+            background-color: #e9ecef !important;
+        }
+    </style>
+</head>
+<body>
+<nav class="navbar navbar-expand-lg navbar-dark bg-dark">
+    <div class="container-fluid">
+        <span class="navbar-brand">Debrid Manager</span>
+    </div>
+</nav>
+
+<div class="container mt-4">
+    <div class="row">
+        <div class="col-md-8">
+            <div class="mb-3">
+                <label for="magnetURI" class="form-label">Magnet Link</label>
+                <textarea class="form-control" id="magnetURI" rows="3"></textarea>
+            </div>
+            <div class="mb-3">
+                <label for="selectArr" class="form-label">Enter Category</label>
+                <input type="email" class="form-control" id="selectArr" placeholder="Enter Category(e.g sonarr, radarr, radarr4k)">
+            </div>
+            <div class="form-check">
+                <input class="form-check-input" type="checkbox" value="" id="isSymlink">
+                <label class="form-check-label" for="isSymlink">
+                    Not Symlink(Download real files instead of symlinks from Debrid)
+                </label>
+            </div>
+            <div class="mt-3">
+                <button class="btn btn-primary" id="addToArr">
+                    Add to Arr
+                </button>
+            </div>
+        </div>
+<!--        <div class="col-md-6">-->
+
+<!--                        <div class="mb-3 d-none">-->
+<!--                            <select class="form-select mb-3 select2-ajax" id="selectContent">-->
+<!--                                <option></option>-->
+<!--                            </select>-->
+<!--                        </div>-->
+<!--                        <div class="mb-3 d-none">-->
+<!--                            <select class="form-select mb-3 select2-multi" id="selectSeason" multiple-->
+<!--                                    style="width: 100%; display: none;">-->
+<!--                                <option value="all">Select All</option>-->
+<!--                            </select>-->
+<!--                        </div>-->
+<!--                        <div class="mb-4 d-none">-->
+<!--                            <select class="form-select mb-3 select2-multi" id="selectEpisode" multiple-->
+<!--                                    style="width: 100%; display: none;">-->
+<!--                                <option value="all">Select All</option>-->
+<!--                            </select>-->
+<!--                        </div>-->
+
+<!--        </div>-->
+    </div>
+</div>
+
+<!-- Bootstrap JS and Popper.js -->
+<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.0-alpha1/dist/js/bootstrap.bundle.min.js"></script>
+<!-- jQuery -->
+<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>
+    $(document).ready(function () {
+        let $selectArr = $('#selectArr');
+        let $selectContent = $('#selectContent');
+        let $selectSeason = $('#selectSeason');
+        let $selectEpisode = $('#selectEpisode');
+        let $addBtn = $('#addToArr');
+        const $contentSearch = $('#contentSearch');
+        const $searchResults = $('#searchResults');
+        let isSonarr = true;
+        let searchTimeout;
+        let selectedArr, selectedContent, selectedSeasons, selectedEpisodes;
+
+        // Initially show only selectArr, hide others
+        $selectSeason.hide().closest('.mb-3').hide();
+        $selectEpisode.hide().closest('.mb-3').hide();
+
+        // Initialize Select2
+        $('.select2-multi').select2({
+            theme: 'bootstrap-5',
+            width: '100%',
+            placeholder: 'Select options',
+            allowClear: true
+        });
+
+        // Also hide the Select2 containers
+        $('.select2-container--bootstrap-5').hide();
+
+        $selectContent.select2({
+            theme: 'bootstrap-5',
+            width: '100%',
+            placeholder: 'Search shows/movies...',
+            allowClear: true,
+            minimumInputLength: 2,
+            ajax: {
+                url: '/internal/search',
+                dataType: 'json',
+                delay: 250,
+                data: function (params) {
+                    return {
+                        term: params.term
+                    };
+                },
+                processResults: function (data) {
+                    return {
+                        results: data.map(function (item) {
+                            return {
+                                id: item.id,
+                                text: item.media_type === 'movie' ? item.title : item.name,
+                                media_type: item.media_type,
+                                poster: item.poster_path ?
+                                    'https://image.tmdb.org/t/p/w92' + item.poster_path : null,
+                                year: item.media_type === 'movie' ?
+                                    (item.release_date ? item.release_date.substring(0, 4) : '') :
+                                    (item.first_air_date ? item.first_air_date.substring(0, 4) : '')
+                            };
+                        })
+                    };
+                },
+                cache: true
+            },
+            templateResult: formatResult,
+            templateSelection: formatSelection
+        });
+
+        function formatResult(item) {
+            if (!item.id) return item.text;
+
+            return $(`
+        <div class="select2-result d-flex align-items-center gap-2">
+            ${item.poster ?
+                `<img src="${item.poster}" style="width: 45px; height: 68px; object-fit: cover;">` :
+                '<div style="width: 45px; height: 68px; background: #eee;"></div>'
+            }
+            <div>
+                <div class="fw-bold">${item.text}</div>
+                <small class="text-muted">
+                    ${item.year} • ${item.media_type === 'movie' ? 'Movie' : 'TV Series'}
+                </small>
+            </div>
+        </div>
+    `);
+        }
+
+        function formatSelection(item) {
+            if (!item.id) return item.text;
+            return item.text + (item.year ? ` (${item.year})` : '');
+        }
+
+// Handle selection
+        $selectContent.on('select2:select', function (e) {
+            selectedContent = e.params.data.id;
+            const mediaType = e.params.data.media_type;
+
+            if (mediaType === 'tv') {
+                $selectSeason.show().closest('.mb-3').show();
+                $selectSeason.next('.select2-container--bootstrap-5').show();
+                // Fetch seasons (your existing seasons fetch code)
+                fetch(`/internal/seasons/${selectedContent}`)
+                    .then(response => response.json())
+                    .then(seasons => {
+                        $selectSeason.empty().append('<option value="all">Select All</option>');
+                        seasons.forEach(season => {
+                            $selectSeason.append(`<option value="${season}">Season ${season}</option>`);
+                        });
+                        $selectSeason.trigger('change.select2');
+                    })
+                    .catch(error => console.error('Error fetching seasons:', error));
+            } else {
+                // For movies, show the Add to Arr button directly
+                $selectSeason.hide().closest('.mb-3').hide();
+                $selectSeason.next('.select2-container--bootstrap-5').hide();
+                $selectEpisode.hide().closest('.mb-3').hide();
+                $selectEpisode.next('.select2-container--bootstrap-5').hide();
+                $addBtn.show();
+            }
+        });
+
+        // Fetch Arrs
+        function fetchArrs() {
+            fetch('/internal/arrs')
+                .then(response => response.json())
+                .then(arrs => {
+                    $selectArr.empty().append('<option value="">Select Arr</option>');
+                    arrs.forEach(arr => {
+                        $selectArr.append(`<option value="${arr.name}">${arr.name}</option>`);
+                    });
+                })
+                .catch(error => console.error('Error fetching arrs:', error));
+        }
+
+        // Handle content selection
+        $selectContent.change(function () {
+            selectedContent = $(this).val();
+            selectedArr = $selectArr.val();
+
+            if (!selectedContent) {
+                $selectSeason.hide().closest('.mb-3').hide();
+                $selectSeason.next('.select2-container--bootstrap-5').hide();
+                $selectEpisode.hide().closest('.mb-3').hide();
+                $selectEpisode.next('.select2-container--bootstrap-5').hide();
+                return;
+            }
+
+            if (isSonarr) {
+                $selectSeason.show().closest('.mb-3').show();
+                $selectSeason.next('.select2-container--bootstrap-5').show();
+                // Fetch seasons
+                fetch(`/internal/seasons/${selectedContent}`)
+                    .then(response => response.json())
+                    .then(seasons => {
+                        $selectSeason.empty().append('<option value="all">Select All</option>');
+                        seasons.forEach(season => {
+                            $selectSeason.append(`<option value="${season}">Season ${season}</option>`);
+                        });
+                        $selectSeason.trigger('change.select2');
+                    })
+                    .catch(error => console.error('Error fetching seasons:', error));
+            } else {
+                // For Radarr, show the Add to Arr button directly
+                $selectSeason.hide().closest('.mb-3').hide();
+                $selectSeason.next('.select2-container--bootstrap-5').hide();
+                $selectEpisode.hide().closest('.mb-3').hide();
+                $selectEpisode.next('.select2-container--bootstrap-5').hide();
+                $addBtn.show();
+            }
+        });
+
+        // Handle season selection
+        $selectSeason.change(function () {
+            selectedSeasons = $(this).val();
+            console.log('Selected seasons:', selectedSeasons);
+
+            if (!selectedSeasons || selectedSeasons.includes('all')) {
+                $selectEpisode.hide().closest('.mb-3').hide();
+                $selectEpisode.next('.select2-container--bootstrap-5').hide();
+                $addBtn.show();
+                return;
+            }
+
+            $selectEpisode.show().closest('.mb-3').show();
+            $selectEpisode.next('.select2-container--bootstrap-5').show();
+            fetch(`/internal/episodes/${selectedContent}?seasons=${selectedSeasons.join(',')}`)
+                .then(response => response.json())
+                .then(episodes => {
+                    $selectEpisode.empty().append('<option value="all">Select All</option>');
+                    episodes.forEach(episode => {
+                        $selectEpisode.append(`<option value="${episode}">Episode ${episode}</option>`);
+                    });
+                    $selectEpisode.trigger('change.select2');
+                })
+                .catch(error => console.error('Error fetching episodes:', error));
+            $addBtn.show();
+        });
+
+        $addBtn.click(function () {
+            let oldText = $(this).text();
+            $(this).prop('disabled', true).prepend('<span class="spinner-border spinner-border-sm me-2" role="status" aria-hidden="true"></span>');
+            let magnet = $('#magnetURI').val();
+            if (!magnet) {
+                $(this).prop('disabled', false).text(oldText);
+                alert('Please provide a magnet link or upload a torrent file!');
+                
+                return;
+            }
+            let data = {
+                arr: $selectArr.val(),
+                url: magnet,
+                notSymlink: $('#isSymlink').is(':checked'),
+            };
+            console.log('Adding to Arr:', data);
+            fetch('/internal/add', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(data)
+            })
+                .then(async response => {
+                    if (!response.ok) {
+                        const errorText = await response.text();
+                        throw new Error(errorText);
+                    }
+                    return response.json();
+                })
+                .then(result => {
+                    console.log('Added to Arr:', result);
+                    $(this).prop('disabled', false).text(oldText);
+                    alert('Added to Arr successfully!');
+                })
+                .catch(error => {
+                    $(this).prop('disabled', false).text(oldText);
+                    alert(`Error adding to Arr: ${error.message || error}`);
+                });
+        });
+
+        // Initial fetch of Arrs
+        //fetchArrs();
+    });
+</script>
+</body>
+</html>

pkg/qbit/server/torrent_handlers.go

@@ -0,0 +1,176 @@
+package server
+
+import (
+	"context"
+	"goBlack/common"
+	"goBlack/pkg/qbit/shared"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+func (s *Server) 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 := s.qbit.Storage.GetAll(category, filter, hashes)
+	common.JSONResponse(w, torrents, http.StatusOK)
+}
+
+func (s *Server) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	contentType := strings.Split(r.Header.Get("Content-Type"), ";")[0]
+	switch contentType {
+	case "multipart/form-data":
+		err := r.ParseMultipartForm(32 << 20) // 32MB max memory
+		if err != nil {
+			s.logger.Printf("Error parsing form: %v\n", err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+	case "application/x-www-form-urlencoded":
+		err := r.ParseForm()
+		if err != nil {
+			s.logger.Printf("Error parsing form: %v\n", err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+	}
+
+	isSymlink := strings.ToLower(r.FormValue("sequentialDownload")) != "true"
+	s.logger.Printf("isSymlink: %v\n", isSymlink)
+	urls := r.FormValue("urls")
+	category := r.FormValue("category")
+
+	var urlList []string
+	if urls != "" {
+		urlList = strings.Split(urls, "\n")
+	}
+
+	ctx = context.WithValue(ctx, "isSymlink", isSymlink)
+	for _, url := range urlList {
+		if err := s.qbit.AddMagnet(ctx, url, category); err != nil {
+			s.logger.Printf("Error adding magnet: %v\n", err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+	}
+
+	if contentType == "multipart/form-data" && len(r.MultipartForm.File["torrents"]) > 0 {
+		files := r.MultipartForm.File["torrents"]
+		for _, fileHeader := range files {
+			if err := s.qbit.AddTorrent(ctx, fileHeader, category); err != nil {
+				s.logger.Printf("Error adding torrent: %v\n", err)
+				http.Error(w, err.Error(), http.StatusBadRequest)
+				return
+			}
+		}
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) 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
+	}
+	for _, hash := range hashes {
+		s.qbit.Storage.Delete(hash)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := s.qbit.Storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go s.qbit.PauseTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := s.qbit.Storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go s.qbit.ResumeTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) handleTorrentRecheck(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := s.qbit.Storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go s.qbit.RefreshTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (s *Server) handleCategories(w http.ResponseWriter, r *http.Request) {
+	var categories = map[string]shared.TorrentCategory{}
+	for _, cat := range s.qbit.Categories {
+		path := filepath.Join(s.qbit.DownloadFolder, cat)
+		categories[cat] = shared.TorrentCategory{
+			Name:     cat,
+			SavePath: path,
+		}
+	}
+	common.JSONResponse(w, categories, http.StatusOK)
+}
+
+func (s *Server) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	name := r.Form.Get("category")
+	if name == "" {
+		http.Error(w, "No name provided", http.StatusBadRequest)
+		return
+	}
+
+	s.qbit.Categories = append(s.qbit.Categories, name)
+
+	common.JSONResponse(w, nil, http.StatusOK)
+}
+
+func (s *Server) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
+	hash := r.URL.Query().Get("hash")
+	torrent := s.qbit.Storage.Get(hash)
+	properties := s.qbit.GetTorrentProperties(torrent)
+	common.JSONResponse(w, properties, http.StatusOK)
+}
+
+func (s *Server) handleTorrentFiles(w http.ResponseWriter, r *http.Request) {
+	hash := r.URL.Query().Get("hash")
+	torrent := s.qbit.Storage.Get(hash)
+	if torrent == nil {
+		return
+	}
+	files := s.qbit.GetTorrentFiles(torrent)
+	common.JSONResponse(w, files, http.StatusOK)
+}

pkg/qbit/server/ui_handlers.go

@@ -0,0 +1,114 @@
+package server
+
+import (
+	"embed"
+	"encoding/json"
+	"goBlack/common"
+	"goBlack/pkg/arr"
+	"html/template"
+	"net/http"
+)
+
+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"`
+}
+
+//go:embed static/index.html
+var content embed.FS
+
+func (s *Server) handleHome(w http.ResponseWriter, r *http.Request) {
+	tmpl, err := template.ParseFS(content, "static/index.html")
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	err = tmpl.Execute(w, nil)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+}
+
+func (s *Server) handleGetArrs(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	common.JSONResponse(w, s.qbit.Arrs.GetAll(), http.StatusOK)
+}
+
+func (s *Server) handleContent(w http.ResponseWriter, r *http.Request) {
+	arrName := r.URL.Query().Get("arr")
+	_arr := s.qbit.Arrs.Get(arrName)
+	if _arr == nil {
+		http.Error(w, "Invalid arr", http.StatusBadRequest)
+		return
+	}
+	contents := _arr.GetContents()
+	w.Header().Set("Content-Type", "application/json")
+	common.JSONResponse(w, contents, http.StatusOK)
+}
+
+func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) {
+	// arrName := r.URL.Query().Get("arr")
+	term := r.URL.Query().Get("term")
+	results, err := arr.SearchTMDB(term)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	w.Header().Set("Content-Type", "application/json")
+	common.JSONResponse(w, results.Results, http.StatusOK)
+}
+
+func (s *Server) handleSeasons(w http.ResponseWriter, r *http.Request) {
+	// arrId := r.URL.Query().Get("arrId")
+	// contentId := chi.URLParam(r, "contentId")
+	seasons := []string{"Season 1", "Season 2", "Season 3", "Season 4", "Season 5"}
+	w.Header().Set("Content-Type", "application/json")
+	common.JSONResponse(w, seasons, http.StatusOK)
+}
+
+func (s *Server) handleEpisodes(w http.ResponseWriter, r *http.Request) {
+	// arrId := r.URL.Query().Get("arrId")
+	// contentId := chi.URLParam(r, "contentId")
+	// seasonIds := strings.Split(r.URL.Query().Get("seasons"), ",")
+	episodes := []string{"Episode 1", "Episode 2", "Episode 3", "Episode 4", "Episode 5"}
+	w.Header().Set("Content-Type", "application/json")
+	common.JSONResponse(w, episodes, http.StatusOK)
+}
+
+func (s *Server) 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 := s.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(s)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+	common.JSONResponse(w, importReq, http.StatusOK)
+}

pkg/qbit/shared/downloader.go

@@ -0,0 +1,111 @@
+package shared
+
+import (
+	"fmt"
+	"goBlack/common"
+	"goBlack/pkg/debrid"
+	"goBlack/pkg/downloaders"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+func (q *QBit) processManualFiles(debridTorrent *debrid.Torrent) (string, error) {
+	q.logger.Printf("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.Printf("No download link found for %s\n", 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.Printf("Error downloading %s: %v\n", link.DownloadLink, err)
+			} else {
+				q.logger.Printf("Downloaded %s successfully\n", link.DownloadLink)
+			}
+		}(link)
+	}
+	wg.Wait()
+	q.logger.Printf("Downloaded all files for %s\n", 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))
+
+	q.logger.Printf("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)
+	}
+	torrentSymlinkPath := filepath.Join(q.DownloadFolder, debridTorrent.Arr.Name, torrentPath) // /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)
+	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.Println("File is ready:", f.Path)
+		q.createSymLink(torrentSymlinkPath, torrentRclonePath, f)
+	}
+	return torrentPath, nil
+}
+
+func (q *QBit) getTorrentPath(rclonePath string, debridTorrent *debrid.Torrent) (string, error) {
+	for {
+		torrentPath := debridTorrent.GetMountFolder(rclonePath)
+		if torrentPath != "" {
+			return torrentPath, nil
+		}
+		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.Name) // debridFolder/MyTVShow/MyTVShow.S01E01.720p.mkv
+	err := os.Symlink(torrentFilePath, fullPath)
+	if err != nil {
+		q.logger.Printf("Failed to create symlink: %s: %v\n", fullPath, err)
+	}
+	// Check if the file exists
+	if !common.FileReady(fullPath) {
+		q.logger.Printf("Symlink not ready: %s\n", fullPath)
+	}
+}

pkg/qbit/shared/qbit.go

@@ -0,0 +1,46 @@
+package shared
+
+import (
+	"cmp"
+	"goBlack/common"
+	"goBlack/pkg/arr"
+	"goBlack/pkg/debrid"
+	"log"
+	"os"
+)
+
+type QBit struct {
+	Username        string   `json:"username"`
+	Password        string   `json:"password"`
+	Port            string   `json:"port"`
+	DownloadFolder  string   `json:"download_folder"`
+	Categories      []string `json:"categories"`
+	Debrid          *debrid.DebridService
+	cache           *common.Cache
+	Storage         *TorrentStorage
+	debug           bool
+	logger          *log.Logger
+	Arrs            *arr.Storage
+	RefreshInterval int
+}
+
+func NewQBit(config *common.Config, deb *debrid.DebridService, cache *common.Cache, logger *log.Logger) *QBit {
+	cfg := config.QBitTorrent
+	port := cmp.Or(cfg.Port, os.Getenv("QBIT_PORT"), "8182")
+	refreshInterval := cmp.Or(cfg.RefreshInterval, 10)
+	arrs := arr.NewStorage()
+	return &QBit{
+		Username:        cfg.Username,
+		Password:        cfg.Password,
+		Port:            port,
+		DownloadFolder:  cfg.DownloadFolder,
+		Categories:      cfg.Categories,
+		Debrid:          deb,
+		cache:           cache,
+		debug:           cfg.Debug,
+		Storage:         NewTorrentStorage("torrents.json"),
+		logger:          logger,
+		Arrs:            arrs,
+		RefreshInterval: refreshInterval,
+	}
+}

pkg/qbit/shared/storage.go

@@ -0,0 +1,140 @@
+package shared
+
+import (
+	"encoding/json"
+	"os"
+	"sync"
+)
+
+type TorrentStorage struct {
+	torrents map[string]*Torrent
+	mu       sync.RWMutex
+	order    []string
+}
+
+func loadTorrentsFromJSON(filename string) (map[string]*Torrent, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+	torrents := make(map[string]*Torrent)
+	if err := json.Unmarshal(data, &torrents); err != nil {
+		return nil, err
+	}
+	return torrents, nil
+}
+
+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)
+	}
+	// Create a new TorrentStorage
+	return &TorrentStorage{
+		torrents: torrents,
+		order:    order,
+	}
+}
+
+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)
+}
+
+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
+}
+
+func (ts *TorrentStorage) GetByID(id string) *Torrent {
+	ts.mu.RLock()
+	defer ts.mu.RUnlock()
+	for _, torrent := range ts.torrents {
+		if torrent.ID == id {
+			return torrent
+		}
+	}
+	return nil
+}
+
+func (ts *TorrentStorage) Get(hash string) *Torrent {
+	ts.mu.RLock()
+	defer ts.mu.RUnlock()
+	return ts.torrents[hash]
+}
+
+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]
+		if category != "" && torrent.Category != category {
+			continue
+		}
+		if filter != "" && torrent.State != filter {
+			continue
+		}
+		torrents = append(torrents, torrent)
+	}
+	if len(hashes) > 0 {
+		filtered := make([]*Torrent, 0, len(torrents))
+		for _, hash := range hashes {
+			if torrent := ts.torrents[hash]; torrent != nil {
+				filtered = append(filtered, torrent)
+			}
+		}
+		torrents = filtered
+	}
+	return torrents
+}
+
+func (ts *TorrentStorage) Update(torrent *Torrent) {
+	ts.mu.Lock()
+	defer ts.mu.Unlock()
+	ts.torrents[torrent.Hash] = torrent
+}
+
+func (ts *TorrentStorage) Delete(hash 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
+		}
+	}
+	// Delete the torrent folder
+	if torrent.ContentPath != "" {
+		err := os.RemoveAll(torrent.ContentPath)
+		if err != nil {
+			return
+		}
+	}
+}
+
+func (ts *TorrentStorage) Save(filename string) error {
+	ts.mu.RLock()
+	defer ts.mu.RUnlock()
+	data, err := json.Marshal(ts.torrents)
+	if err != nil {
+		return err
+	}
+	return os.WriteFile(filename, data, 0644)
+}

pkg/qbit/shared/structs.go

@@ -0,0 +1,423 @@
+package shared
+
+import "goBlack/pkg/debrid"
+
+type BuildInfo struct {
+	Libtorrent string `json:"libtorrent"`
+	Bitness    int    `json:"bitness"`
+	Boost      string `json:"boost"`
+	Openssl    string `json:"openssl"`
+	Qt         string `json:"qt"`
+	Zlib       string `json:"zlib"`
+}
+
+type AppPreferences struct {
+	AddTrackers                        string   `json:"add_trackers"`
+	AddTrackersEnabled                 bool     `json:"add_trackers_enabled"`
+	AltDlLimit                         int      `json:"alt_dl_limit"`
+	AltUpLimit                         int      `json:"alt_up_limit"`
+	AlternativeWebuiEnabled            bool     `json:"alternative_webui_enabled"`
+	AlternativeWebuiPath               string   `json:"alternative_webui_path"`
+	AnnounceIp                         string   `json:"announce_ip"`
+	AnnounceToAllTiers                 bool     `json:"announce_to_all_tiers"`
+	AnnounceToAllTrackers              bool     `json:"announce_to_all_trackers"`
+	AnonymousMode                      bool     `json:"anonymous_mode"`
+	AsyncIoThreads                     int      `json:"async_io_threads"`
+	AutoDeleteMode                     int      `json:"auto_delete_mode"`
+	AutoTmmEnabled                     bool     `json:"auto_tmm_enabled"`
+	AutorunEnabled                     bool     `json:"autorun_enabled"`
+	AutorunProgram                     string   `json:"autorun_program"`
+	BannedIPs                          string   `json:"banned_IPs"`
+	BittorrentProtocol                 int      `json:"bittorrent_protocol"`
+	BypassAuthSubnetWhitelist          string   `json:"bypass_auth_subnet_whitelist"`
+	BypassAuthSubnetWhitelistEnabled   bool     `json:"bypass_auth_subnet_whitelist_enabled"`
+	BypassLocalAuth                    bool     `json:"bypass_local_auth"`
+	CategoryChangedTmmEnabled          bool     `json:"category_changed_tmm_enabled"`
+	CheckingMemoryUse                  int      `json:"checking_memory_use"`
+	CreateSubfolderEnabled             bool     `json:"create_subfolder_enabled"`
+	CurrentInterfaceAddress            string   `json:"current_interface_address"`
+	CurrentNetworkInterface            string   `json:"current_network_interface"`
+	Dht                                bool     `json:"dht"`
+	DiskCache                          int      `json:"disk_cache"`
+	DiskCacheTtl                       int      `json:"disk_cache_ttl"`
+	DlLimit                            int      `json:"dl_limit"`
+	DontCountSlowTorrents              bool     `json:"dont_count_slow_torrents"`
+	DyndnsDomain                       string   `json:"dyndns_domain"`
+	DyndnsEnabled                      bool     `json:"dyndns_enabled"`
+	DyndnsPassword                     string   `json:"dyndns_password"`
+	DyndnsService                      int      `json:"dyndns_service"`
+	DyndnsUsername                     string   `json:"dyndns_username"`
+	EmbeddedTrackerPort                int      `json:"embedded_tracker_port"`
+	EnableCoalesceReadWrite            bool     `json:"enable_coalesce_read_write"`
+	EnableEmbeddedTracker              bool     `json:"enable_embedded_tracker"`
+	EnableMultiConnectionsFromSameIp   bool     `json:"enable_multi_connections_from_same_ip"`
+	EnableOsCache                      bool     `json:"enable_os_cache"`
+	EnablePieceExtentAffinity          bool     `json:"enable_piece_extent_affinity"`
+	EnableSuperSeeding                 bool     `json:"enable_super_seeding"`
+	EnableUploadSuggestions            bool     `json:"enable_upload_suggestions"`
+	Encryption                         int      `json:"encryption"`
+	ExportDir                          string   `json:"export_dir"`
+	ExportDirFin                       string   `json:"export_dir_fin"`
+	FilePoolSize                       int      `json:"file_pool_size"`
+	IncompleteFilesExt                 bool     `json:"incomplete_files_ext"`
+	IpFilterEnabled                    bool     `json:"ip_filter_enabled"`
+	IpFilterPath                       string   `json:"ip_filter_path"`
+	IpFilterTrackers                   bool     `json:"ip_filter_trackers"`
+	LimitLanPeers                      bool     `json:"limit_lan_peers"`
+	LimitTcpOverhead                   bool     `json:"limit_tcp_overhead"`
+	LimitUtpRate                       bool     `json:"limit_utp_rate"`
+	ListenPort                         int      `json:"listen_port"`
+	Locale                             string   `json:"locale"`
+	Lsd                                bool     `json:"lsd"`
+	MailNotificationAuthEnabled        bool     `json:"mail_notification_auth_enabled"`
+	MailNotificationEmail              string   `json:"mail_notification_email"`
+	MailNotificationEnabled            bool     `json:"mail_notification_enabled"`
+	MailNotificationPassword           string   `json:"mail_notification_password"`
+	MailNotificationSender             string   `json:"mail_notification_sender"`
+	MailNotificationSmtp               string   `json:"mail_notification_smtp"`
+	MailNotificationSslEnabled         bool     `json:"mail_notification_ssl_enabled"`
+	MailNotificationUsername           string   `json:"mail_notification_username"`
+	MaxActiveDownloads                 int      `json:"max_active_downloads"`
+	MaxActiveTorrents                  int      `json:"max_active_torrents"`
+	MaxActiveUploads                   int      `json:"max_active_uploads"`
+	MaxConnec                          int      `json:"max_connec"`
+	MaxConnecPerTorrent                int      `json:"max_connec_per_torrent"`
+	MaxRatio                           int      `json:"max_ratio"`
+	MaxRatioAct                        int      `json:"max_ratio_act"`
+	MaxRatioEnabled                    bool     `json:"max_ratio_enabled"`
+	MaxSeedingTime                     int      `json:"max_seeding_time"`
+	MaxSeedingTimeEnabled              bool     `json:"max_seeding_time_enabled"`
+	MaxUploads                         int      `json:"max_uploads"`
+	MaxUploadsPerTorrent               int      `json:"max_uploads_per_torrent"`
+	OutgoingPortsMax                   int      `json:"outgoing_ports_max"`
+	OutgoingPortsMin                   int      `json:"outgoing_ports_min"`
+	Pex                                bool     `json:"pex"`
+	PreallocateAll                     bool     `json:"preallocate_all"`
+	ProxyAuthEnabled                   bool     `json:"proxy_auth_enabled"`
+	ProxyIp                            string   `json:"proxy_ip"`
+	ProxyPassword                      string   `json:"proxy_password"`
+	ProxyPeerConnections               bool     `json:"proxy_peer_connections"`
+	ProxyPort                          int      `json:"proxy_port"`
+	ProxyTorrentsOnly                  bool     `json:"proxy_torrents_only"`
+	ProxyType                          int      `json:"proxy_type"`
+	ProxyUsername                      string   `json:"proxy_username"`
+	QueueingEnabled                    bool     `json:"queueing_enabled"`
+	RandomPort                         bool     `json:"random_port"`
+	RecheckCompletedTorrents           bool     `json:"recheck_completed_torrents"`
+	ResolvePeerCountries               bool     `json:"resolve_peer_countries"`
+	RssAutoDownloadingEnabled          bool     `json:"rss_auto_downloading_enabled"`
+	RssMaxArticlesPerFeed              int      `json:"rss_max_articles_per_feed"`
+	RssProcessingEnabled               bool     `json:"rss_processing_enabled"`
+	RssRefreshInterval                 int      `json:"rss_refresh_interval"`
+	SavePath                           string   `json:"save_path"`
+	SavePathChangedTmmEnabled          bool     `json:"save_path_changed_tmm_enabled"`
+	SaveResumeDataInterval             int      `json:"save_resume_data_interval"`
+	ScanDirs                           ScanDirs `json:"scan_dirs"`
+	ScheduleFromHour                   int      `json:"schedule_from_hour"`
+	ScheduleFromMin                    int      `json:"schedule_from_min"`
+	ScheduleToHour                     int      `json:"schedule_to_hour"`
+	ScheduleToMin                      int      `json:"schedule_to_min"`
+	SchedulerDays                      int      `json:"scheduler_days"`
+	SchedulerEnabled                   bool     `json:"scheduler_enabled"`
+	SendBufferLowWatermark             int      `json:"send_buffer_low_watermark"`
+	SendBufferWatermark                int      `json:"send_buffer_watermark"`
+	SendBufferWatermarkFactor          int      `json:"send_buffer_watermark_factor"`
+	SlowTorrentDlRateThreshold         int      `json:"slow_torrent_dl_rate_threshold"`
+	SlowTorrentInactiveTimer           int      `json:"slow_torrent_inactive_timer"`
+	SlowTorrentUlRateThreshold         int      `json:"slow_torrent_ul_rate_threshold"`
+	SocketBacklogSize                  int      `json:"socket_backlog_size"`
+	StartPausedEnabled                 bool     `json:"start_paused_enabled"`
+	StopTrackerTimeout                 int      `json:"stop_tracker_timeout"`
+	TempPath                           string   `json:"temp_path"`
+	TempPathEnabled                    bool     `json:"temp_path_enabled"`
+	TorrentChangedTmmEnabled           bool     `json:"torrent_changed_tmm_enabled"`
+	UpLimit                            int      `json:"up_limit"`
+	UploadChokingAlgorithm             int      `json:"upload_choking_algorithm"`
+	UploadSlotsBehavior                int      `json:"upload_slots_behavior"`
+	Upnp                               bool     `json:"upnp"`
+	UpnpLeaseDuration                  int      `json:"upnp_lease_duration"`
+	UseHttps                           bool     `json:"use_https"`
+	UtpTcpMixedMode                    int      `json:"utp_tcp_mixed_mode"`
+	WebUiAddress                       string   `json:"web_ui_address"`
+	WebUiBanDuration                   int      `json:"web_ui_ban_duration"`
+	WebUiClickjackingProtectionEnabled bool     `json:"web_ui_clickjacking_protection_enabled"`
+	WebUiCsrfProtectionEnabled         bool     `json:"web_ui_csrf_protection_enabled"`
+	WebUiDomainList                    string   `json:"web_ui_domain_list"`
+	WebUiHostHeaderValidationEnabled   bool     `json:"web_ui_host_header_validation_enabled"`
+	WebUiHttpsCertPath                 string   `json:"web_ui_https_cert_path"`
+	WebUiHttpsKeyPath                  string   `json:"web_ui_https_key_path"`
+	WebUiMaxAuthFailCount              int      `json:"web_ui_max_auth_fail_count"`
+	WebUiPort                          int      `json:"web_ui_port"`
+	WebUiSecureCookieEnabled           bool     `json:"web_ui_secure_cookie_enabled"`
+	WebUiSessionTimeout                int      `json:"web_ui_session_timeout"`
+	WebUiUpnp                          bool     `json:"web_ui_upnp"`
+	WebUiUsername                      string   `json:"web_ui_username"`
+	WebUiPassword                      string   `json:"web_ui_password"`
+	SSLKey                             string   `json:"ssl_key"`
+	SSLCert                            string   `json:"ssl_cert"`
+	RSSDownloadRepack                  string   `json:"rss_download_repack_proper_episodes"`
+	RSSSmartEpisodeFilters             string   `json:"rss_smart_episode_filters"`
+	WebUiUseCustomHttpHeaders          bool     `json:"web_ui_use_custom_http_headers"`
+	WebUiUseCustomHttpHeadersEnabled   bool     `json:"web_ui_use_custom_http_headers_enabled"`
+}
+
+type ScanDirs struct{}
+
+type TorrentCategory struct {
+	Name     string `json:"name"`
+	SavePath string `json:"savePath"`
+}
+
+type Torrent struct {
+	ID            string          `json:"-"`
+	DebridTorrent *debrid.Torrent `json:"-"`
+	TorrentPath   string          `json:"-"`
+
+	AddedOn           int64   `json:"added_on,omitempty"`
+	AmountLeft        int64   `json:"amount_left"`
+	AutoTmm           bool    `json:"auto_tmm"`
+	Availability      float64 `json:"availability,omitempty"`
+	Category          string  `json:"category,omitempty"`
+	Completed         int64   `json:"completed"`
+	CompletionOn      int     `json:"completion_on,omitempty"`
+	ContentPath       string  `json:"content_path"`
+	DlLimit           int     `json:"dl_limit"`
+	Dlspeed           int     `json:"dlspeed"`
+	Downloaded        int64   `json:"downloaded"`
+	DownloadedSession int64   `json:"downloaded_session"`
+	Eta               int     `json:"eta"`
+	FlPiecePrio       bool    `json:"f_l_piece_prio,omitempty"`
+	ForceStart        bool    `json:"force_start,omitempty"`
+	Hash              string  `json:"hash"`
+	LastActivity      int64   `json:"last_activity,omitempty"`
+	MagnetUri         string  `json:"magnet_uri,omitempty"`
+	MaxRatio          int     `json:"max_ratio,omitempty"`
+	MaxSeedingTime    int     `json:"max_seeding_time,omitempty"`
+	Name              string  `json:"name,omitempty"`
+	NumComplete       int     `json:"num_complete,omitempty"`
+	NumIncomplete     int     `json:"num_incomplete,omitempty"`
+	NumLeechs         int     `json:"num_leechs,omitempty"`
+	NumSeeds          int     `json:"num_seeds,omitempty"`
+	Priority          int     `json:"priority,omitempty"`
+	Progress          float64 `json:"progress"`
+	Ratio             int     `json:"ratio,omitempty"`
+	RatioLimit        int     `json:"ratio_limit,omitempty"`
+	SavePath          string  `json:"save_path"`
+	SeedingTimeLimit  int     `json:"seeding_time_limit,omitempty"`
+	SeenComplete      int64   `json:"seen_complete,omitempty"`
+	SeqDl             bool    `json:"seq_dl"`
+	Size              int64   `json:"size,omitempty"`
+	State             string  `json:"state,omitempty"`
+	SuperSeeding      bool    `json:"super_seeding"`
+	Tags              string  `json:"tags,omitempty"`
+	TimeActive        int     `json:"time_active,omitempty"`
+	TotalSize         int64   `json:"total_size,omitempty"`
+	Tracker           string  `json:"tracker,omitempty"`
+	UpLimit           int64   `json:"up_limit,omitempty"`
+	Uploaded          int64   `json:"uploaded,omitempty"`
+	UploadedSession   int64   `json:"uploaded_session,omitempty"`
+	Upspeed           int     `json:"upspeed,omitempty"`
+}
+
+func (t *Torrent) IsReady() bool {
+	return t.AmountLeft <= 0 && t.TorrentPath != ""
+}
+
+type TorrentProperties struct {
+	AdditionDate           int64  `json:"addition_date,omitempty"`
+	Comment                string `json:"comment,omitempty"`
+	CompletionDate         int64  `json:"completion_date,omitempty"`
+	CreatedBy              string `json:"created_by,omitempty"`
+	CreationDate           int64  `json:"creation_date,omitempty"`
+	DlLimit                int    `json:"dl_limit,omitempty"`
+	DlSpeed                int    `json:"dl_speed,omitempty"`
+	DlSpeedAvg             int    `json:"dl_speed_avg,omitempty"`
+	Eta                    int    `json:"eta,omitempty"`
+	LastSeen               int64  `json:"last_seen,omitempty"`
+	NbConnections          int    `json:"nb_connections,omitempty"`
+	NbConnectionsLimit     int    `json:"nb_connections_limit,omitempty"`
+	Peers                  int    `json:"peers,omitempty"`
+	PeersTotal             int    `json:"peers_total,omitempty"`
+	PieceSize              int64  `json:"piece_size,omitempty"`
+	PiecesHave             int64  `json:"pieces_have,omitempty"`
+	PiecesNum              int64  `json:"pieces_num,omitempty"`
+	Reannounce             int    `json:"reannounce,omitempty"`
+	SavePath               string `json:"save_path,omitempty"`
+	SeedingTime            int    `json:"seeding_time,omitempty"`
+	Seeds                  int    `json:"seeds,omitempty"`
+	SeedsTotal             int    `json:"seeds_total,omitempty"`
+	ShareRatio             int    `json:"share_ratio,omitempty"`
+	TimeElapsed            int64  `json:"time_elapsed,omitempty"`
+	TotalDownloaded        int64  `json:"total_downloaded,omitempty"`
+	TotalDownloadedSession int64  `json:"total_downloaded_session,omitempty"`
+	TotalSize              int64  `json:"total_size,omitempty"`
+	TotalUploaded          int64  `json:"total_uploaded,omitempty"`
+	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"`
+	UpSpeedAvg             int    `json:"up_speed_avg,omitempty"`
+}
+
+type TorrentFile struct {
+	Index        int     `json:"index,omitempty"`
+	Name         string  `json:"name,omitempty"`
+	Size         int64   `json:"size,omitempty"`
+	Progress     int     `json:"progress,omitempty"`
+	Priority     int     `json:"priority,omitempty"`
+	IsSeed       bool    `json:"is_seed,omitempty"`
+	PieceRange   []int   `json:"piece_range,omitempty"`
+	Availability float64 `json:"availability,omitempty"`
+}
+
+func NewAppPreferences() *AppPreferences {
+	preferences := &AppPreferences{
+		AddTrackers:                        "",
+		AddTrackersEnabled:                 false,
+		AltDlLimit:                         10240,
+		AltUpLimit:                         10240,
+		AlternativeWebuiEnabled:            false,
+		AlternativeWebuiPath:               "",
+		AnnounceIp:                         "",
+		AnnounceToAllTiers:                 true,
+		AnnounceToAllTrackers:              false,
+		AnonymousMode:                      false,
+		AsyncIoThreads:                     4,
+		AutoDeleteMode:                     0,
+		AutoTmmEnabled:                     false,
+		AutorunEnabled:                     false,
+		AutorunProgram:                     "",
+		BannedIPs:                          "",
+		BittorrentProtocol:                 0,
+		BypassAuthSubnetWhitelist:          "",
+		BypassAuthSubnetWhitelistEnabled:   false,
+		BypassLocalAuth:                    false,
+		CategoryChangedTmmEnabled:          false,
+		CheckingMemoryUse:                  32,
+		CreateSubfolderEnabled:             true,
+		CurrentInterfaceAddress:            "",
+		CurrentNetworkInterface:            "",
+		Dht:                                true,
+		DiskCache:                          -1,
+		DiskCacheTtl:                       60,
+		DlLimit:                            0,
+		DontCountSlowTorrents:              false,
+		DyndnsDomain:                       "changeme.dyndns.org",
+		DyndnsEnabled:                      false,
+		DyndnsPassword:                     "",
+		DyndnsService:                      0,
+		DyndnsUsername:                     "",
+		EmbeddedTrackerPort:                9000,
+		EnableCoalesceReadWrite:            true,
+		EnableEmbeddedTracker:              false,
+		EnableMultiConnectionsFromSameIp:   false,
+		EnableOsCache:                      true,
+		EnablePieceExtentAffinity:          false,
+		EnableSuperSeeding:                 false,
+		EnableUploadSuggestions:            false,
+		Encryption:                         0,
+		ExportDir:                          "",
+		ExportDirFin:                       "",
+		FilePoolSize:                       40,
+		IncompleteFilesExt:                 false,
+		IpFilterEnabled:                    false,
+		IpFilterPath:                       "",
+		IpFilterTrackers:                   false,
+		LimitLanPeers:                      true,
+		LimitTcpOverhead:                   false,
+		LimitUtpRate:                       true,
+		ListenPort:                         31193,
+		Locale:                             "en",
+		Lsd:                                true,
+		MailNotificationAuthEnabled:        false,
+		MailNotificationEmail:              "",
+		MailNotificationEnabled:            false,
+		MailNotificationPassword:           "",
+		MailNotificationSender:             "qBittorrentNotification@example.com",
+		MailNotificationSmtp:               "smtp.changeme.com",
+		MailNotificationSslEnabled:         false,
+		MailNotificationUsername:           "",
+		MaxActiveDownloads:                 3,
+		MaxActiveTorrents:                  5,
+		MaxActiveUploads:                   3,
+		MaxConnec:                          500,
+		MaxConnecPerTorrent:                100,
+		MaxRatio:                           -1,
+		MaxRatioAct:                        0,
+		MaxRatioEnabled:                    false,
+		MaxSeedingTime:                     -1,
+		MaxSeedingTimeEnabled:              false,
+		MaxUploads:                         -1,
+		MaxUploadsPerTorrent:               -1,
+		OutgoingPortsMax:                   0,
+		OutgoingPortsMin:                   0,
+		Pex:                                true,
+		PreallocateAll:                     false,
+		ProxyAuthEnabled:                   false,
+		ProxyIp:                            "0.0.0.0",
+		ProxyPassword:                      "",
+		ProxyPeerConnections:               false,
+		ProxyPort:                          8080,
+		ProxyTorrentsOnly:                  false,
+		ProxyType:                          0,
+		ProxyUsername:                      "",
+		QueueingEnabled:                    false,
+		RandomPort:                         false,
+		RecheckCompletedTorrents:           false,
+		ResolvePeerCountries:               true,
+		RssAutoDownloadingEnabled:          false,
+		RssMaxArticlesPerFeed:              50,
+		RssProcessingEnabled:               false,
+		RssRefreshInterval:                 30,
+		SavePathChangedTmmEnabled:          false,
+		SaveResumeDataInterval:             60,
+		ScanDirs:                           ScanDirs{},
+		ScheduleFromHour:                   8,
+		ScheduleFromMin:                    0,
+		ScheduleToHour:                     20,
+		ScheduleToMin:                      0,
+		SchedulerDays:                      0,
+		SchedulerEnabled:                   false,
+		SendBufferLowWatermark:             10,
+		SendBufferWatermark:                500,
+		SendBufferWatermarkFactor:          50,
+		SlowTorrentDlRateThreshold:         2,
+		SlowTorrentInactiveTimer:           60,
+		SlowTorrentUlRateThreshold:         2,
+		SocketBacklogSize:                  30,
+		StartPausedEnabled:                 false,
+		StopTrackerTimeout:                 1,
+		TempPathEnabled:                    false,
+		TorrentChangedTmmEnabled:           true,
+		UpLimit:                            0,
+		UploadChokingAlgorithm:             1,
+		UploadSlotsBehavior:                0,
+		Upnp:                               true,
+		UpnpLeaseDuration:                  0,
+		UseHttps:                           false,
+		UtpTcpMixedMode:                    0,
+		WebUiAddress:                       "*",
+		WebUiBanDuration:                   3600,
+		WebUiClickjackingProtectionEnabled: true,
+		WebUiCsrfProtectionEnabled:         true,
+		WebUiDomainList:                    "*",
+		WebUiHostHeaderValidationEnabled:   true,
+		WebUiHttpsCertPath:                 "",
+		WebUiHttpsKeyPath:                  "",
+		WebUiMaxAuthFailCount:              5,
+		WebUiPort:                          8080,
+		WebUiSecureCookieEnabled:           true,
+		WebUiSessionTimeout:                3600,
+		WebUiUpnp:                          false,
+
+		// Fields in the struct but not in the JSON (set to zero values):
+		WebUiPassword:                    "",
+		SSLKey:                           "",
+		SSLCert:                          "",
+		RSSDownloadRepack:                "",
+		RSSSmartEpisodeFilters:           "",
+		WebUiUseCustomHttpHeaders:        false,
+		WebUiUseCustomHttpHeadersEnabled: false,
+	}
+	return preferences
+}

pkg/qbit/shared/torrent.go

@@ -0,0 +1,274 @@
+package shared
+
+import (
+	"cmp"
+	"context"
+	"fmt"
+	"github.com/google/uuid"
+	"goBlack/common"
+	"goBlack/pkg/arr"
+	"goBlack/pkg/debrid"
+	"io"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// All torrent related helpers goes here
+
+func (q *QBit) AddMagnet(ctx context.Context, url, category string) error {
+	magnet, err := common.GetMagnetFromUrl(url)
+	if err != nil {
+		return fmt.Errorf("error parsing magnet link: %w", err)
+	}
+	err = q.Process(ctx, magnet, category)
+	if err != nil {
+		return fmt.Errorf("failed to process torrent: %w", err)
+	}
+	return nil
+}
+
+func (q *QBit) AddTorrent(ctx context.Context, fileHeader *multipart.FileHeader, category string) error {
+	file, _ := fileHeader.Open()
+	defer file.Close()
+	var reader io.Reader = file
+	magnet, err := common.GetMagnetFromFile(reader, fileHeader.Filename)
+	if err != nil {
+		return fmt.Errorf("error reading file: %s \n %w", fileHeader.Filename, err)
+	}
+	err = q.Process(ctx, magnet, category)
+	if err != nil {
+		return fmt.Errorf("failed to process torrent: %w", err)
+	}
+	return nil
+}
+
+func (q *QBit) Process(ctx context.Context, magnet *common.Magnet, category string) error {
+	torrent := q.CreateTorrentFromMagnet(magnet, category)
+	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)
+	if err != nil || debridTorrent == nil {
+		if debridTorrent != nil {
+			go debridTorrent.Delete()
+		}
+		if err == nil {
+			err = fmt.Errorf("failed to process torrent")
+		}
+		return err
+	}
+	torrent = q.UpdateTorrentMin(torrent, debridTorrent)
+	q.Storage.AddOrUpdate(torrent)
+	go q.ProcessFiles(torrent, debridTorrent, a, isSymlink) // We can send async for file processing not to delay the response
+	return nil
+}
+
+func (q *QBit) CreateTorrentFromMagnet(magnet *common.Magnet, category string) *Torrent {
+	torrent := &Torrent{
+		ID:        uuid.NewString(),
+		Hash:      strings.ToLower(magnet.InfoHash),
+		Name:      magnet.Name,
+		Size:      magnet.Size,
+		Category:  category,
+		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) {
+	for debridTorrent.Status != "downloaded" {
+		progress := debridTorrent.Progress
+		q.logger.Printf("%s Download Progress: %.2f%%", debridTorrent.Debrid.GetName(), progress)
+		time.Sleep(5 * time.Second)
+		dbT, err := debridTorrent.Debrid.CheckStatus(debridTorrent, isSymlink)
+		if err != nil {
+			q.logger.Printf("Error checking status: %v", err)
+			go debridTorrent.Delete()
+			q.MarkAsFailed(torrent)
+			_ = arr.Refresh()
+			return
+		}
+		debridTorrent = dbT
+		torrent = q.UpdateTorrentMin(torrent, debridTorrent)
+	}
+	var (
+		torrentPath string
+		err         error
+	)
+	debridTorrent.Arr = arr
+	if isSymlink {
+		torrentPath, err = q.ProcessSymlink(debridTorrent)
+	} else {
+		torrentPath, err = q.processManualFiles(debridTorrent)
+	}
+	if err != nil {
+		q.MarkAsFailed(torrent)
+		go debridTorrent.Delete()
+		q.logger.Printf("Error: %v", err)
+		return
+	}
+	torrent.TorrentPath = filepath.Base(torrentPath)
+	q.UpdateTorrent(torrent, debridTorrent)
+	_ = arr.Refresh()
+}
+
+func (q *QBit) MarkAsFailed(t *Torrent) *Torrent {
+	t.State = "error"
+	q.Storage.AddOrUpdate(t)
+	return t
+}
+
+func (q *QBit) UpdateTorrentMin(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
+	if debridTorrent == nil {
+		return t
+	}
+
+	addedOn, err := time.Parse(time.RFC3339, debridTorrent.Added)
+	if err != nil {
+		addedOn = time.Now()
+	}
+	totalSize := debridTorrent.Bytes
+	progress := cmp.Or(debridTorrent.Progress, 100)
+	progress = progress / 100.0
+	sizeCompleted := int64(float64(totalSize) * progress)
+
+	var speed int
+	if debridTorrent.Speed != 0 {
+		speed = debridTorrent.Speed
+	}
+	var eta int
+	if speed != 0 {
+		eta = int(totalSize-sizeCompleted) / speed
+	}
+	t.ID = debridTorrent.Id
+	t.Name = debridTorrent.Name
+	t.AddedOn = addedOn.Unix()
+	t.DebridTorrent = debridTorrent
+	t.Size = totalSize
+	t.Completed = sizeCompleted
+	t.Downloaded = sizeCompleted
+	t.DownloadedSession = sizeCompleted
+	t.Uploaded = sizeCompleted
+	t.UploadedSession = sizeCompleted
+	t.AmountLeft = totalSize - sizeCompleted
+	t.Progress = progress
+	t.Eta = eta
+	t.Dlspeed = speed
+	t.Upspeed = speed
+	t.SavePath = filepath.Join(q.DownloadFolder, t.Category) + string(os.PathSeparator)
+	t.ContentPath = filepath.Join(t.SavePath, t.Name) + string(os.PathSeparator)
+	return t
+}
+
+func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
+	db := debridTorrent.Debrid
+	rcLoneMount := db.GetMountPath()
+	if debridTorrent == nil && t.ID != "" {
+		debridTorrent, _ = db.GetTorrent(t.ID)
+	}
+	if debridTorrent == nil {
+		q.logger.Printf("Torrent with ID %s not found in %s", t.ID, db.GetName())
+		return t
+	}
+	if debridTorrent.Status != "downloaded" {
+		debridTorrent, _ = db.GetTorrent(t.ID)
+	}
+
+	if t.TorrentPath == "" {
+		t.TorrentPath = filepath.Base(debridTorrent.GetMountFolder(rcLoneMount))
+	}
+	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
+
+	if t.IsReady() {
+		t.State = "pausedUP"
+		q.Storage.Update(t)
+		return t
+	}
+
+	ticker := time.NewTicker(2 * time.Second)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			if t.IsReady() {
+				t.State = "pausedUP"
+				q.Storage.Update(t)
+				return t
+			}
+			updatedT := q.UpdateTorrent(t, debridTorrent)
+			t = updatedT
+
+		case <-time.After(10 * time.Minute): // Add a timeout
+			return t
+		}
+	}
+}
+
+func (q *QBit) ResumeTorrent(t *Torrent) bool {
+	return true
+}
+
+func (q *QBit) PauseTorrent(t *Torrent) bool {
+	return true
+}
+
+func (q *QBit) RefreshTorrent(t *Torrent) bool {
+	return true
+}
+
+func (q *QBit) GetTorrentProperties(t *Torrent) *TorrentProperties {
+	return &TorrentProperties{
+		AdditionDate:           t.AddedOn,
+		Comment:                "Debrid Blackhole <https://github.com/sirrobot01/debrid-blackhole>",
+		CreatedBy:              "Debrid Blackhole <https://github.com/sirrobot01/debrid-blackhole>",
+		CreationDate:           t.AddedOn,
+		DlLimit:                -1,
+		UpLimit:                -1,
+		DlSpeed:                t.Dlspeed,
+		UpSpeed:                t.Upspeed,
+		TotalSize:              t.Size,
+		TotalUploaded:          t.Uploaded,
+		TotalDownloaded:        t.Downloaded,
+		TotalUploadedSession:   t.UploadedSession,
+		TotalDownloadedSession: t.DownloadedSession,
+		LastSeen:               time.Now().Unix(),
+		NbConnectionsLimit:     100,
+		Peers:                  0,
+		PeersTotal:             2,
+		SeedingTime:            1,
+		Seeds:                  100,
+		ShareRatio:             100,
+	}
+}
+
+func (q *QBit) GetTorrentFiles(t *Torrent) []*TorrentFile {
+	files := make([]*TorrentFile, 0)
+	if t.DebridTorrent == nil {
+		return files
+	}
+	for index, file := range t.DebridTorrent.Files {
+		files = append(files, &TorrentFile{
+			Index: index,
+			Name:  file.Path,
+			Size:  file.Size,
+		})
+	}
+	return files
+}

pkg/qbit/shared/utils.go

@@ -0,0 +1,25 @@
+package shared
+
+import (
+	"goBlack/common"
+	"goBlack/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/shared/worker.go

@@ -0,0 +1,37 @@
+package shared
+
+import (
+	"context"
+	"time"
+)
+
+func (q *QBit) StartWorker(ctx context.Context) {
+	q.logger.Println("Qbit Worker started")
+	q.StartRefreshWorker(ctx)
+}
+
+func (q *QBit) StartRefreshWorker(ctx context.Context) {
+	refreshCtx := context.WithValue(ctx, "worker", "refresh")
+	refreshTicker := time.NewTicker(time.Duration(q.RefreshInterval) * time.Second)
+	for {
+		select {
+		case <-refreshCtx.Done():
+			q.logger.Println("Qbit Refresh Worker stopped")
+			return
+		case <-refreshTicker.C:
+			torrents := q.Storage.GetAll("", "", nil)
+			if len(torrents) > 0 {
+				q.RefreshArrs()
+			}
+		}
+	}
+}
+
+func (q *QBit) RefreshArrs() {
+	for _, arr := range q.Arrs.GetAll() {
+		err := arr.Refresh()
+		if err != nil {
+			return
+		}
+	}
+}