Changelog 0.2.0 (#1)

* Changelog 0.2.0

pkg/debrid/debrid.go

@@ -0,0 +1,149 @@
+package debrid
+
+import (
+	"fmt"
+	"github.com/anacrolix/torrent/metainfo"
+	"goBlack/common"
+	"log"
+	"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(infohashes []string) map[string]bool
+	GetMountPath() string
+	GetDownloadUncached() bool
+	GetTorrent(id string) (*Torrent, error)
+	GetName() string
+	GetLogger() *log.Logger
+}
+
+type Debrid struct {
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *common.RLHTTPClient
+	cache            *common.Cache
+	MountPath        string
+	logger           *log.Logger
+}
+
+func NewDebrid(dc common.DebridConfig, cache *common.Cache) Service {
+	switch dc.Name {
+	case "realdebrid":
+		return NewRealDebrid(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
+	}
+	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
+}
+
+func GetLocalCache(infohashes []string, cache *common.Cache) ([]string, map[string]bool) {
+	result := make(map[string]bool)
+	hashes := make([]string, len(infohashes))
+
+	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 hashes, result
+}
+
+func ProcessQBitTorrent(d Service, magnet *common.Magnet, category string) (*Torrent, error) {
+	arr := &Arr{
+		CompletedFolder: category,
+	}
+	debridTorrent := &Torrent{
+		InfoHash: magnet.InfoHash,
+		Magnet:   magnet,
+		Name:     magnet.Name,
+		Arr:      arr,
+		Size:     magnet.Size,
+	}
+	logger := d.GetLogger()
+	logger.Printf("Torrent Name: %s", debridTorrent.Name)
+	if !d.GetDownloadUncached() {
+		hash, exists := d.IsAvailable([]string{debridTorrent.InfoHash})[debridTorrent.InfoHash]
+		if !exists || !hash {
+			return debridTorrent, fmt.Errorf("torrent is not cached")
+		}
+		logger.Printf("Torrent: %s is cached", debridTorrent.Name)
+	}
+
+	debridTorrent, err := d.SubmitMagnet(debridTorrent)
+	if err != nil || debridTorrent.Id == "" {
+		return nil, err
+	}
+	return d.CheckStatus(debridTorrent)
+}

pkg/debrid/realdebrid.go

@@ -0,0 +1,248 @@
+package debrid
+
+import (
+	"encoding/json"
+	"fmt"
+	"goBlack/common"
+	"goBlack/pkg/debrid/structs"
+	"log"
+	"net/http"
+	gourl "net/url"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+type RealDebrid struct {
+	Host             string `json:"host"`
+	APIKey           string
+	DownloadUncached bool
+	client           *common.RLHTTPClient
+	cache            *common.Cache
+	MountPath        string
+	logger           *log.Logger
+}
+
+func (r *RealDebrid) GetMountPath() string {
+	return r.MountPath
+}
+
+func (r *RealDebrid) GetName() string {
+	return "realdebrid"
+}
+
+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.SAMPLEMATCH, name) {
+			continue
+		}
+		fileId := f.ID
+		file := &TorrentFile{
+			Name: name,
+			Path: filepath.Join(common.RemoveExtension(data.OriginalFilename), name),
+			Size: int64(f.Bytes),
+			Id:   strconv.Itoa(fileId),
+		}
+		files = append(files, *file)
+	}
+	return files
+}
+
+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 {
+		hash, exists := r.IsAvailable([]string{torrent.InfoHash})[torrent.InfoHash]
+		if !exists || !hash {
+			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(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)
+		resp, err := r.client.MakeRequest(http.MethodGet, url, nil)
+		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
+	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) GetTorrent(id string) (*Torrent, error) {
+	torrent := &Torrent{}
+	url := fmt.Sprintf("%s/torrents/info/%s", r.Host, id)
+	resp, err := r.client.MakeRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return torrent, err
+	}
+	var data structs.RealDebridTorrentInfo
+	err = json.Unmarshal(resp, &data)
+	if err != nil {
+		return torrent, err
+	}
+	name := common.RemoveExtension(data.OriginalFilename)
+	torrent.Id = id
+	torrent.Name = name
+	torrent.Bytes = data.Bytes
+	torrent.Folder = name
+	torrent.Progress = data.Progress
+	torrent.Status = data.Status
+	files := GetTorrentFiles(data)
+	torrent.Files = files
+	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 {
+			log.Println("ERROR Checking file: ", err)
+			return torrent, err
+		}
+		var data structs.RealDebridTorrentInfo
+		err = json.Unmarshal(resp, &data)
+		status := data.Status
+		torrent.Folder = common.RemoveExtension(data.OriginalFilename)
+		torrent.Bytes = data.Bytes
+		torrent.Progress = data.Progress
+		torrent.Speed = data.Speed
+		torrent.Seeders = data.Seeders
+		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 := 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())
+			_, 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
+		}
+
+	}
+	return torrent, nil
+}
+
+func (r *RealDebrid) DownloadLink(torrent *Torrent) error {
+	return nil
+}
+
+func (r *RealDebrid) GetDownloadUncached() bool {
+	return r.DownloadUncached
+}
+
+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{
+		Host:             dc.Host,
+		APIKey:           dc.APIKey,
+		DownloadUncached: dc.DownloadUncached,
+		client:           client,
+		cache:            cache,
+		MountPath:        dc.Folder,
+		logger:           logger,
+	}
+}

pkg/debrid/structs/realdebrid.go

@@ -0,0 +1,96 @@
+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    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"`
+}
+
+// 5e6e2e77fd3921a7903a41336c844cc409bf8788/14527C07BDFDDFC642963238BB6E7507B9742947/66A1CD1A5C7F4014877A51AC2620E857E3BB4D16

pkg/debrid/torrent.go

@@ -0,0 +1,152 @@
+package debrid
+
+import (
+	"encoding/json"
+	"goBlack/common"
+	"log"
+	"net/http"
+	gourl "net/url"
+	"os"
+	"path/filepath"
+	"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"`
+	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"`
+	Progress int            `json:"progress"`
+	Speed    int            `json:"speed"`
+	Seeders  int            `json:"seeders"`
+
+	Debrid *Debrid
+	Arr    *Arr
+}
+
+func (t *Torrent) GetSymlinkFolder(parent string) string {
+	return filepath.Join(parent, t.Arr.CompletedFolder, t.Folder)
+}
+
+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
+}

pkg/proxy/proxy.go

@@ -0,0 +1,336 @@
+package proxy
+
+import (
+	"bytes"
+	"cmp"
+	"encoding/xml"
+	"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.Service, 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,
+		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 == "" {
+		//Get torrent file from http link
+		//Takes too long, not worth it
+		//magnet, err := common.OpenMagnetHttpURL(magnetLink)
+		//if err == nil && magnet != nil && magnet.InfoHash != "" {
+		//	log.Printf("Magnet: %s", magnet.InfoHash)
+		//}
+	}
+	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 {
+		p.logger.Println("No items found in RSS feed")
+		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() {
+	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$")),
+		UrlMatches(regexp.MustCompile("^.*/api\\?t=(search|tvsearch|movie)(&.*)?$"))).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)
+	p.logger.Printf("[*] Starting proxy server on %s\n", portFmt)
+	p.logger.Fatal(http.ListenAndServe(fmt.Sprintf("%s", portFmt), proxy))
+}

pkg/qbit/handlers.go

@@ -0,0 +1,39 @@
+package qbit
+
+import (
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+func (q *QBit) AddRoutes(r chi.Router) http.Handler {
+	r.Route("/api/v2", func(r chi.Router) {
+		r.Post("/auth/login", q.handleLogin)
+
+		r.Group(func(r chi.Router) {
+			r.Use(q.authMiddleware)
+			r.Route("/torrents", func(r chi.Router) {
+				r.Use(HashesCtx)
+				r.Get("/info", q.handleTorrentsInfo)
+				r.Post("/add", q.handleTorrentsAdd)
+				r.Post("/delete", q.handleTorrentsDelete)
+				r.Get("/categories", q.handleCategories)
+				r.Post("/createCategory", q.handleCreateCategory)
+
+				r.Get("/pause", q.handleTorrentsPause)
+				r.Get("/resume", q.handleTorrentsResume)
+				r.Get("/recheck", q.handleTorrentRecheck)
+				r.Get("/properties", q.handleTorrentProperties)
+			})
+
+			r.Route("/app", func(r chi.Router) {
+				r.Get("/version", q.handleVersion)
+				r.Get("/webapiVersion", q.handleWebAPIVersion)
+				r.Get("/preferences", q.handlePreferences)
+				r.Get("/buildInfo", q.handleBuildInfo)
+				r.Get("/shutdown", q.shutdown)
+			})
+		})
+
+	})
+	return r
+}

pkg/qbit/handlers_app.go

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

pkg/qbit/handlers_auth.go

@@ -0,0 +1,50 @@
+package qbit
+
+import (
+	"net/http"
+	"time"
+)
+
+func (q *QBit) handleLogin(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	username := r.Form.Get("username")
+	password := r.Form.Get("password")
+
+	// In a real implementation, you'd verify credentials here
+	// For this mock, we'll accept any non-empty username and password
+	if username == "" || password == "" {
+		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
+		return
+	}
+	if username != q.Username || password != q.Password {
+		http.Error(w, "Invalid credentials", http.StatusUnauthorized)
+		return
+	}
+
+	// Generate a new SID
+	sid, err := generateSID()
+	if err != nil {
+		http.Error(w, "Failed to generate session ID", http.StatusInternalServerError)
+		return
+	}
+
+	// Set the SID cookie
+	http.SetCookie(w, &http.Cookie{
+		Name:     cookieName,
+		Value:    sid,
+		Path:     "/",
+		HttpOnly: true,
+		MaxAge:   315360000,
+	})
+
+	// Store the session
+	sessions.Store(sid, time.Now().Add(24*time.Hour))
+
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("Ok."))
+}

pkg/qbit/handlers_torrent.go

@@ -0,0 +1,171 @@
+package qbit
+
+import (
+	"goBlack/common"
+	"io"
+	"net/http"
+	"path/filepath"
+	"strings"
+)
+
+func (q *QBit) handleTorrentsInfo(w http.ResponseWriter, r *http.Request) {
+	//log all url params
+	ctx := r.Context()
+	category := strings.Trim(r.URL.Query().Get("category"), "")
+	filter := strings.Trim(r.URL.Query().Get("filter"), "")
+	hashes, _ := ctx.Value("hashes").([]string)
+	torrents := q.storage.GetAll(category, filter, hashes)
+	JSONResponse(w, torrents, http.StatusOK)
+}
+
+func (q *QBit) handleTorrentsAdd(w http.ResponseWriter, r *http.Request) {
+	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 {
+			q.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 {
+			q.logger.Printf("Error parsing form: %v\n", err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+	}
+
+	files := r.MultipartForm.File["torrents"]
+	urls := r.FormValue("urls")
+	category := r.FormValue("category")
+
+	if len(files) == 0 && urls == "" {
+		http.Error(w, "No torrent provided", http.StatusBadRequest)
+		return
+	}
+
+	var urlList []string
+	if urls != "" {
+		urlList = strings.Split(urls, "\n")
+	}
+
+	for _, url := range urlList {
+		magnet, err := common.GetMagnetFromUrl(url)
+		if err != nil {
+			q.logger.Printf("Error parsing magnet link: %v\n", err)
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			return
+		}
+		go q.Process(magnet, category)
+
+	}
+
+	for _, fileHeader := range files {
+		file, _ := fileHeader.Open()
+		defer file.Close()
+		var reader io.Reader = file
+		magnet, err := common.GetMagnetFromFile(reader, fileHeader.Filename)
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusBadRequest)
+			q.logger.Printf("Error reading file: %s", fileHeader.Filename)
+			return
+		}
+		go q.Process(magnet, category)
+	}
+	w.WriteHeader(http.StatusOK)
+}
+
+func (q *QBit) handleTorrentsDelete(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	if len(hashes) == 0 {
+		http.Error(w, "No hashes provided", http.StatusBadRequest)
+		return
+	}
+	for _, hash := range hashes {
+		q.storage.Delete(hash)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (q *QBit) handleTorrentsPause(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := q.storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go q.PauseTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (q *QBit) handleTorrentsResume(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := q.storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go q.ResumeTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (q *QBit) handleTorrentRecheck(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	hashes, _ := ctx.Value("hashes").([]string)
+	for _, hash := range hashes {
+		torrent := q.storage.Get(hash)
+		if torrent == nil {
+			continue
+		}
+		go q.RefreshTorrent(torrent)
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
+func (q *QBit) handleCategories(w http.ResponseWriter, r *http.Request) {
+	var categories = map[string]TorrentCategory{}
+	for _, cat := range q.Categories {
+		path := filepath.Join(q.DownloadFolder, cat)
+		categories[cat] = TorrentCategory{
+			Name:     cat,
+			SavePath: path,
+		}
+	}
+	JSONResponse(w, categories, http.StatusOK)
+}
+
+func (q *QBit) handleCreateCategory(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		http.Error(w, "Failed to parse form data", http.StatusBadRequest)
+		return
+	}
+
+	name := r.Form.Get("category")
+	if name == "" {
+		http.Error(w, "No name provided", http.StatusBadRequest)
+		return
+	}
+
+	q.Categories = append(q.Categories, name)
+
+	JSONResponse(w, nil, http.StatusOK)
+}
+
+func (q *QBit) handleTorrentProperties(w http.ResponseWriter, r *http.Request) {
+	hash := r.URL.Query().Get("hash")
+	torrent := q.storage.Get(hash)
+	properties := q.GetTorrentProperties(torrent)
+	JSONResponse(w, properties, http.StatusOK)
+}

pkg/qbit/main.go

@@ -0,0 +1,67 @@
+package qbit
+
+import (
+	"cmp"
+	"fmt"
+	"github.com/go-chi/chi/v5"
+	"github.com/go-chi/chi/v5/middleware"
+	"goBlack/common"
+	"goBlack/pkg/debrid"
+	"log"
+	"net/http"
+	"os"
+	"sync"
+)
+
+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.Service
+	cache          *common.Cache
+	storage        *TorrentStorage
+	debug          bool
+	logger         *log.Logger
+}
+
+var (
+	sessions sync.Map
+)
+
+const (
+	sidLength  = 32
+	cookieName = "SID"
+)
+
+func NewQBit(config *common.Config, deb debrid.Service, cache *common.Cache) *QBit {
+	cfg := config.QBitTorrent
+	storage := NewTorrentStorage("torrents.json")
+	port := cmp.Or(cfg.Port, os.Getenv("QBIT_PORT"), "8182")
+	return &QBit{
+		Username:       cfg.Username,
+		Password:       cfg.Password,
+		Port:           port,
+		DownloadFolder: cfg.DownloadFolder,
+		Categories:     cfg.Categories,
+		debrid:         deb,
+		cache:          cache,
+		debug:          cfg.Debug,
+		storage:        storage,
+		logger:         common.NewLogger("QBit", os.Stdout),
+	}
+}
+
+func (q *QBit) Start() {
+
+	r := chi.NewRouter()
+	r.Use(middleware.Logger)
+	r.Use(middleware.Recoverer)
+
+	q.AddRoutes(r)
+
+	q.logger.Printf("Starting QBit server on :%s", q.Port)
+	port := fmt.Sprintf(":%s", q.Port)
+	q.logger.Fatal(http.ListenAndServe(port, r))
+}

pkg/qbit/middleware.go

@@ -0,0 +1,41 @@
+package qbit
+
+import (
+	"context"
+	"crypto/subtle"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+	"strings"
+)
+
+func (q *QBit) authMiddleware(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		user, pass, ok := r.BasicAuth()
+		if !ok {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+		if subtle.ConstantTimeCompare([]byte(user), []byte(q.Username)) != 1 || subtle.ConstantTimeCompare([]byte(pass), []byte(q.Password)) != 1 {
+			http.Error(w, "Unauthorized", http.StatusUnauthorized)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+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/qbit.go

@@ -0,0 +1,101 @@
+package qbit
+
+import (
+	"github.com/google/uuid"
+	"goBlack/common"
+	"goBlack/pkg/debrid"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+)
+
+func (q *QBit) Process(magnet *common.Magnet, category string) (*Torrent, error) {
+	torrent := q.CreateTorrentFromMagnet(magnet, category)
+	go q.storage.AddOrUpdate(torrent)
+	debridTorrent, err := debrid.ProcessQBitTorrent(q.debrid, magnet, category)
+	if err != nil || debridTorrent == nil {
+		// Mark as failed
+		q.MarkAsFailed(torrent)
+		return torrent, err
+	}
+	torrent.ID = debridTorrent.Id
+	q.processFiles(torrent, debridTorrent)
+	return torrent, 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",
+		AddedOn:   time.Now().Unix(),
+		MagnetUri: magnet.Link,
+
+		Tracker:        "udp://tracker.opentrackr.org:1337",
+		UpLimit:        -1,
+		DlLimit:        -1,
+		FlPiecePrio:    false,
+		ForceStart:     false,
+		AutoTmm:        false,
+		Availability:   2,
+		MaxRatio:       -1,
+		MaxSeedingTime: -1,
+		NumComplete:    10,
+		NumIncomplete:  0,
+		NumLeechs:      1,
+		Ratio:          1,
+		RatioLimit:     1,
+	}
+	return torrent
+}
+
+func (q *QBit) processFiles(torrent *Torrent, debridTorrent *debrid.Torrent) {
+	var wg sync.WaitGroup
+	files := debridTorrent.Files
+	ready := make(chan debrid.TorrentFile, len(files))
+
+	q.logger.Printf("Checking %d files...", len(files))
+	rCloneMountPath := q.debrid.GetMountPath()
+	path := filepath.Join(q.DownloadFolder, debridTorrent.Arr.CompletedFolder, debridTorrent.Folder) // /mnt/symlinks/{category}/MyTVShow/
+	err := os.MkdirAll(path, os.ModePerm)
+	if err != nil {
+		q.logger.Printf("Failed to create directory: %s\n", path)
+	}
+
+	for _, file := range files {
+		wg.Add(1)
+		go checkFileLoop(&wg, rCloneMountPath, file, ready)
+	}
+
+	go func() {
+		wg.Wait()
+		close(ready)
+	}()
+
+	for f := range ready {
+		q.logger.Println("File is ready:", f.Path)
+		q.createSymLink(path, debridTorrent, f)
+
+	}
+	// Update the torrent when all files are ready
+	q.UpdateTorrent(torrent, debridTorrent)
+	q.logger.Printf("%s COMPLETED \n", debridTorrent.Name)
+}
+
+func (q *QBit) createSymLink(path string, torrent *debrid.Torrent, 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
+	torrentMountPath := filepath.Join(q.debrid.GetMountPath(), torrent.Folder, file.Name) // debridFolder/MyTVShow/MyTVShow.S01E01.720p.mkv
+	_ = os.Symlink(torrentMountPath, fullPath)
+	// Check if the file exists
+	if !fileReady(fullPath) {
+		q.logger.Printf("Failed to create symlink: %s\n", fullPath)
+	}
+}

pkg/qbit/storage.go

@@ -0,0 +1,137 @@
+package qbit
+
+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, len(ts.torrents))
+	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)
+			}
+		}
+		return 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 != "" {
+		os.RemoveAll(torrent.ContentPath)
+	}
+}
+
+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/structs.go

@@ -0,0 +1,404 @@
+package qbit
+
+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                         int64    `json:"alt_dl_limit"`
+	AltUpLimit                         int64    `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                     int64    `json:"async_io_threads"`
+	AutoDeleteMode                     int64    `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                 int64    `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                  int64    `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                          int64    `json:"disk_cache"`
+	DiskCacheTtl                       int64    `json:"disk_cache_ttl"`
+	DlLimit                            int64    `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                      int64    `json:"dyndns_service"`
+	DyndnsUsername                     string   `json:"dyndns_username"`
+	EmbeddedTrackerPort                int64    `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                         int64    `json:"encryption"`
+	ExportDir                          string   `json:"export_dir"`
+	ExportDirFin                       string   `json:"export_dir_fin"`
+	FilePoolSize                       int64    `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                         int64    `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                 int64    `json:"max_active_downloads"`
+	MaxActiveTorrents                  int64    `json:"max_active_torrents"`
+	MaxActiveUploads                   int64    `json:"max_active_uploads"`
+	MaxConnec                          int64    `json:"max_connec"`
+	MaxConnecPerTorrent                int64    `json:"max_connec_per_torrent"`
+	MaxRatio                           int64    `json:"max_ratio"`
+	MaxRatioAct                        int64    `json:"max_ratio_act"`
+	MaxRatioEnabled                    bool     `json:"max_ratio_enabled"`
+	MaxSeedingTime                     int64    `json:"max_seeding_time"`
+	MaxSeedingTimeEnabled              bool     `json:"max_seeding_time_enabled"`
+	MaxUploads                         int64    `json:"max_uploads"`
+	MaxUploadsPerTorrent               int64    `json:"max_uploads_per_torrent"`
+	OutgoingPortsMax                   int64    `json:"outgoing_ports_max"`
+	OutgoingPortsMin                   int64    `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                          int64    `json:"proxy_port"`
+	ProxyTorrentsOnly                  bool     `json:"proxy_torrents_only"`
+	ProxyType                          int64    `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              int64    `json:"rss_max_articles_per_feed"`
+	RssProcessingEnabled               bool     `json:"rss_processing_enabled"`
+	RssRefreshInterval                 int64    `json:"rss_refresh_interval"`
+	SavePath                           string   `json:"save_path"`
+	SavePathChangedTmmEnabled          bool     `json:"save_path_changed_tmm_enabled"`
+	SaveResumeDataInterval             int64    `json:"save_resume_data_interval"`
+	ScanDirs                           ScanDirs `json:"scan_dirs"`
+	ScheduleFromHour                   int64    `json:"schedule_from_hour"`
+	ScheduleFromMin                    int64    `json:"schedule_from_min"`
+	ScheduleToHour                     int64    `json:"schedule_to_hour"`
+	ScheduleToMin                      int64    `json:"schedule_to_min"`
+	SchedulerDays                      int64    `json:"scheduler_days"`
+	SchedulerEnabled                   bool     `json:"scheduler_enabled"`
+	SendBufferLowWatermark             int64    `json:"send_buffer_low_watermark"`
+	SendBufferWatermark                int64    `json:"send_buffer_watermark"`
+	SendBufferWatermarkFactor          int64    `json:"send_buffer_watermark_factor"`
+	SlowTorrentDlRateThreshold         int64    `json:"slow_torrent_dl_rate_threshold"`
+	SlowTorrentInactiveTimer           int64    `json:"slow_torrent_inactive_timer"`
+	SlowTorrentUlRateThreshold         int64    `json:"slow_torrent_ul_rate_threshold"`
+	SocketBacklogSize                  int64    `json:"socket_backlog_size"`
+	StartPausedEnabled                 bool     `json:"start_paused_enabled"`
+	StopTrackerTimeout                 int64    `json:"stop_tracker_timeout"`
+	TempPath                           string   `json:"temp_path"`
+	TempPathEnabled                    bool     `json:"temp_path_enabled"`
+	TorrentChangedTmmEnabled           bool     `json:"torrent_changed_tmm_enabled"`
+	UpLimit                            int64    `json:"up_limit"`
+	UploadChokingAlgorithm             int64    `json:"upload_choking_algorithm"`
+	UploadSlotsBehavior                int64    `json:"upload_slots_behavior"`
+	Upnp                               bool     `json:"upnp"`
+	UpnpLeaseDuration                  int64    `json:"upnp_lease_duration"`
+	UseHttps                           bool     `json:"use_https"`
+	UtpTcpMixedMode                    int64    `json:"utp_tcp_mixed_mode"`
+	WebUiAddress                       string   `json:"web_ui_address"`
+	WebUiBanDuration                   int64    `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              int64    `json:"web_ui_max_auth_fail_count"`
+	WebUiPort                          int64    `json:"web_ui_port"`
+	WebUiSecureCookieEnabled           bool     `json:"web_ui_secure_cookie_enabled"`
+	WebUiSessionTimeout                int64    `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:"-"`
+
+	AddedOn           int64   `json:"added_on,omitempty"`
+	AmountLeft        int64   `json:"amount_left,omitempty"`
+	AutoTmm           bool    `json:"auto_tmm"`
+	Availability      float64 `json:"availability"`
+	Category          string  `json:"category,omitempty"`
+	Completed         int64   `json:"completed,omitempty"`
+	CompletionOn      int64   `json:"completion_on,omitempty"`
+	ContentPath       string  `json:"content_path,omitempty"`
+	DlLimit           int64   `json:"dl_limit,omitempty"`
+	Dlspeed           int64   `json:"dlspeed,omitempty"`
+	Downloaded        int64   `json:"downloaded,omitempty"`
+	DownloadedSession int64   `json:"downloaded_session,omitempty"`
+	Eta               int64   `json:"eta,omitempty"`
+	FlPiecePrio       bool    `json:"f_l_piece_prio"`
+	ForceStart        bool    `json:"force_start"`
+	Hash              string  `json:"hash"`
+	LastActivity      int64   `json:"last_activity,omitempty"`
+	MagnetUri         string  `json:"magnet_uri,omitempty"`
+	MaxRatio          int64   `json:"max_ratio,omitempty"`
+	MaxSeedingTime    int64   `json:"max_seeding_time,omitempty"`
+	Name              string  `json:"name,omitempty"`
+	NumComplete       int64   `json:"num_complete,omitempty"`
+	NumIncomplete     int64   `json:"num_incomplete,omitempty"`
+	NumLeechs         int64   `json:"num_leechs,omitempty"`
+	NumSeeds          int64   `json:"num_seeds,omitempty"`
+	Priority          int64   `json:"priority,omitempty"`
+	Progress          float32 `json:"progress"`
+	Ratio             int64   `json:"ratio,omitempty"`
+	RatioLimit        int64   `json:"ratio_limit,omitempty"`
+	SavePath          string  `json:"save_path,omitempty"`
+	SeedingTimeLimit  int64   `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        int64   `json:"time_active,omitempty"`
+	TotalSize         int64   `json:"total_size,omitempty"`
+	Tracker           string  `json:"tracker,omitempty"`
+	UpLimit           int64   `json:"up_limit,omitempty"`
+	Uploaded          int64   `json:"uploaded,omitempty"`
+	UploadedSession   int64   `json:"uploaded_session,omitempty"`
+	Upspeed           int64   `json:"upspeed,omitempty"`
+}
+
+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                int64  `json:"dl_limit,omitempty"`
+	DlSpeed                int64  `json:"dl_speed,omitempty"`
+	DlSpeedAvg             int64  `json:"dl_speed_avg,omitempty"`
+	Eta                    int64  `json:"eta,omitempty"`
+	LastSeen               int64  `json:"last_seen,omitempty"`
+	NbConnections          int64  `json:"nb_connections,omitempty"`
+	NbConnectionsLimit     int64  `json:"nb_connections_limit,omitempty"`
+	Peers                  int64  `json:"peers,omitempty"`
+	PeersTotal             int64  `json:"peers_total,omitempty"`
+	PieceSize              int64  `json:"piece_size,omitempty"`
+	PiecesHave             int64  `json:"pieces_have,omitempty"`
+	PiecesNum              int64  `json:"pieces_num,omitempty"`
+	Reannounce             int64  `json:"reannounce,omitempty"`
+	SavePath               string `json:"save_path,omitempty"`
+	SeedingTime            int64  `json:"seeding_time,omitempty"`
+	Seeds                  int64  `json:"seeds,omitempty"`
+	SeedsTotal             int64  `json:"seeds_total,omitempty"`
+	ShareRatio             int64  `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                int64  `json:"up_limit,omitempty"`
+	UpSpeed                int64  `json:"up_speed,omitempty"`
+	UpSpeedAvg             int64  `json:"up_speed_avg,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/torrent.go

@@ -0,0 +1,102 @@
+package qbit
+
+import (
+	"cmp"
+	"goBlack/pkg/debrid"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+// All torrent related helpers goes here
+
+func (q *QBit) MarkAsFailed(t *Torrent) *Torrent {
+	t.State = "error"
+	q.storage.AddOrUpdate(t)
+	return t
+}
+
+func (q *QBit) UpdateTorrent(t *Torrent, debridTorrent *debrid.Torrent) *Torrent {
+	if debridTorrent == nil && t.ID != "" {
+		debridTorrent, _ = q.debrid.GetTorrent(t.ID)
+	}
+	if debridTorrent == nil {
+		q.logger.Printf("Torrent with ID %s not found in %s", t.ID, q.debrid.GetName())
+		return t
+	}
+	totalSize := cmp.Or(debridTorrent.Bytes, 1)
+	progress := int64(cmp.Or(debridTorrent.Progress, 100))
+	progress = progress / 100.0
+
+	sizeCompleted := totalSize * progress
+	savePath := filepath.Join(q.DownloadFolder, t.Category) + string(os.PathSeparator)
+	torrentPath := filepath.Join(savePath, debridTorrent.Folder) + string(os.PathSeparator)
+
+	var speed int64
+	if debridTorrent.Speed != 0 {
+		speed = int64(debridTorrent.Speed)
+	}
+	var eta int64
+	if speed != 0 {
+		eta = (totalSize - sizeCompleted) / speed
+	}
+
+	t.Name = debridTorrent.Name
+	t.Size = debridTorrent.Bytes
+	t.Completed = sizeCompleted
+	t.Downloaded = sizeCompleted
+	t.DownloadedSession = sizeCompleted
+	t.Uploaded = sizeCompleted
+	t.UploadedSession = sizeCompleted
+	t.AmountLeft = totalSize - sizeCompleted
+	t.Progress = 100
+	t.SavePath = savePath
+	t.ContentPath = torrentPath
+	t.Eta = eta
+	t.Dlspeed = speed
+	t.Upspeed = speed
+
+	if t.AmountLeft == 0 {
+		t.State = "pausedUP"
+	}
+
+	go q.storage.AddOrUpdate(t)
+	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,
+	}
+}

pkg/qbit/utils.go

@@ -0,0 +1,48 @@
+package qbit
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"encoding/json"
+	"goBlack/pkg/debrid"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sync"
+	"time"
+)
+
+func generateSID() (string, error) {
+	bytes := make([]byte, sidLength)
+	if _, err := rand.Read(bytes); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(bytes), 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)
+}
+
+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
+			}
+		}
+	}
+}